Ok, after a bit of correspondence with Karsten we determined that this
was indeed an issue with the underlying Metal PLAF. So I set the PLAF
to Metal and the same behavior is indeed taking place (under OS X). If
you would please be so kind to look at my SSCCE, I made sure there are
no lines longer than 80 characters and put all the source in one file.
All you have to do to get this working now is:
javac TestApp.java
java TestApp

Thanks for any feedback, Jonck

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.UIManager;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;

/**
* @author jonck
*/
public class TestApp {
   private TestGui gui;
   private TestThread testThread = null;

   public static void main(String args[]) {
       try {
           UIManager.setLookAndFeel(
           "javax.swing.plaf.metal.MetalLookAndFeel");
       } catch (Exception e) {
           System.out.println(e);
       }
       new TestApp();
    }

   public TestApp() {
       setGui(new TestGui(this));
   }

   public void start() {
       if (getTestThread() == null) {
           // set up a simulation worker thread
           setTestThread(new TestThread(this));
           getTestThread().start();
       }
       // enable the stop menu item and disable the start menu item
       getGui().getStop().setEnabled(true);
       getGui().getStart().setEnabled(false);
   }

   public void stop() {
       stopThread();
       /*
        * set the stop menu item to disabled here, and let the
        * start menu-item be enabled by the TestThread
        * when it's all done
        */
       getGui().getStop().setEnabled(false);
   }

   public void quit() {
       stopThread();
       System.exit(0);
   }

   private void stopThread() {
       if (getTestThread() != null) {
           getTestThread().stop();
           setTestThread(null);
       }
   }

   /**
    * @return Returns the gui.
    */
   public TestGui getGui() {
       return gui;
   }
   /**
    * @param gui The gui to set.
    */
   public void setGui(TestGui gui) {
       this.gui = gui;
   }
   /**
    * @return Returns the thread.
    */
   public TestThread getTestThread() {
       return testThread;
   }
   /**
    * @param thread The thread to set.
    */
   public void setTestThread(TestThread thread) {
       this.testThread = thread;
   }

   class TestGui {
        private JFrame mainWindow;
        private JMenuBar menuBar;
        private JMenu fileMenu;
        private JMenuItem start;
        private JMenuItem stop;
        private JMenuItem quit;
        private TestApp app;

        public TestGui(TestApp app) {
            setApp(app);
            initComponents();
        }

        private void initComponents() {
            setMenuBar(new JMenuBar());
            setFileMenu(new JMenu("File"));
            setStart(new JMenuItem("Start"));
            setStop(new JMenuItem("Stop"));
            setQuit(new JMenuItem("Quit"));

            setMainWindow(new JFrame("Test"));
            getMainWindow().setResizable(false);

            getFileMenu().add(getStart());
            getFileMenu().add(getStop());
            getFileMenu().add(getQuit());

            getMenuBar().add(getFileMenu());
            getMainWindow().setJMenuBar(getMenuBar());

            getMainWindow().setSize(100, 100);

            getMainWindow().setVisible(true);

            // gray out stop
            getStop().setEnabled(false);

            // add the menu item listeners
            LocalActionListener actionListener = new LocalActionListener();
            getStart().addActionListener(actionListener);
            getStop().addActionListener(actionListener);
            getQuit().addActionListener(actionListener);
        }

        /**
        * @return Returns the app.
        */
        public TestApp getApp() {
            return app;
        }
        /**
        * @param app The app to set.
        */
        public void setApp(TestApp app) {
            this.app = app;
        }
        private class LocalActionListener implements ActionListener {
            public void actionPerformed(ActionEvent event) {
                Object menuItem = event.getSource();
                if (menuItem.equals(getStart())) {
                    getApp().start();
                } else if (menuItem.equals(getStop())) {
                    getApp().stop();
                } else if (menuItem.equals(getQuit())) {
                    getApp().quit();
                }
            }
        }
        /**
        * @return Returns the fileMenu.
        */
        public JMenu getFileMenu() {
            return fileMenu;
        }
        /**
        * @param fileMenu The fileMenu to set.
        */
        public void setFileMenu(JMenu fileMenu) {
            this.fileMenu = fileMenu;
        }
        /**
        * @return Returns the mainWindow.
        */
        public JFrame getMainWindow() {
            return mainWindow;
        }
        /**
        * @param mainWindow The mainWindow to set.
        */
        public void setMainWindow(JFrame mainWindow) {
            this.mainWindow = mainWindow;
        }
        /**
        * @return Returns the menuBar.
        */
        public JMenuBar getMenuBar() {
            return menuBar;
        }
        /**
        * @param menuBar The menuBar to set.
        */
        public void setMenuBar(JMenuBar menuBar) {
            this.menuBar = menuBar;
        }
        /**
        * @return Returns the quit.
        */
        public JMenuItem getQuit() {
            return quit;
        }
        /**
        * @param quit The quit to set.
        */
        public void setQuit(JMenuItem quit) {
            this.quit = quit;
        }
        /**
        * @return Returns the start.
        */
        public JMenuItem getStart() {
            return start;
        }
        /**
        * @param start The start to set.
        */
        public void setStart(JMenuItem start) {
            this.start = start;
        }
        /**
        * @return Returns the stop.
        */
        public JMenuItem getStop() {
            return stop;
        }
        /**
        * @param stop The stop to set.
        */
        public void setStop(JMenuItem stop) {
            this.stop = stop;
        }
    }

    class TestThread implements Runnable {
        private Object sleepObject = new Object();
        private TestApp app;
        private boolean run = true;

        public TestThread(TestApp app) {
            setApp(app);
        }

        public void run() {
            while (isRun()) {
                synchronized (sleepObject) {
                    try {
                        /*
                        * sleep untill awakened
                        * for simulation purposes only
                        */
                        sleepObject.wait();
                    } catch (InterruptedException e) {
                        System.out.println(e);
                    }
                }
                try {
                    /*
                    * sleep for 10 seconds to simulate activity
                    * before stopping
                    */
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    System.out.println(e);
                }
            }
            /*
            * here enable the menu item start again
            * since this thread is all finished now
            */
            getApp().getGui().getStart().setEnabled(true);
        }

        public void start() {
            Thread testThread = new Thread(this);
            testThread.start();
            testThread = null;
        }

        public void stop() {
            setRun(false);
            // awaken the thread
            synchronized (sleepObject) {
                sleepObject.notify();
            }
        }

        /**
        * @return Returns the run.
        */
        public boolean isRun() {
            return run;
        }
        /**
        * @param run The run to set.
        */
        public void setRun(boolean run) {
            this.run = run;
        }
        /**
        * @return Returns the app.
        */
        public TestApp getApp() {
            return app;
        }
        /**
        * @param app The app to set.
        */
        public void setApp(TestApp app) {
            this.app = app;
        }
    }
}