..this method should be invoked from the event-dispatching thread?

Question

I see this (the title that is) in every single Java demo/example program on this (Sun's) site. However, I just tend to
public static void main(String[] args){
   new whateverTheClassIsCalled();
}And I've seen this approach on other sites and other example programs.
So what exactly is better about this;
    public static void main(String[] args) {
        //Schedule a job for the event-dispatching thread:
        //creating and showing this application's GUI.
        javax.swing.SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                createAndShowGUI();
    }where createAndShowGUI() sets and packs the frame. I just do all this in the class constructor (when it's a JFrame!)
So what does all this thread dispatching stuff mean, why should I use it etc etc.
tia.

Answer 1

Is it just me? For some reason it rubs me the wrong way that swing isn't thread safe. From what I've read, my understanding is that its safe to modify swing components from other threads as long as they haven't asked to be painted. If you don't do paint(), pack() or setVisible(true) until the end of your initialization, you will be safe.
The reason for not being thread safe is almost certainly performance. Swing is slow enough as it is. Since the vast majority of Swing activity takes place in response to events and thus is on the EDT, there usually isn't a problem.
This is a serious nuisance in network and database programs where multiple threads are used. I end up using invokeLater a lot in those cases, but never for initialization. Sun has only started to recomment that recently.
Note that the fireXXX methods do not put the event on the EDT, these simply create Event objects and send them to Listeners. If they are executed off the EDT the Listeners will get called off the EDT.