Initializing Java Swing in the background

I have a question regarding quick initialization of swing components. At the start of my swing application I have a window that pops up with buttons that allow the user to do a variety of things. Is there I way that I can quickly launch that first window and load the rest of the UI (such as other frames and dialogs) in the background so that there is isn't that in开发者_如何学JAVAitial delay.

Thanks,

Is Swing thread safe?

Yes. Ish. You could do something similar to:

public static void main(String [] args) {
    // Construct main Frame on Swing EDT thread
    Runnable goVisible = new Runnable() {
        public void run() {
             JFrame mainFrame = new JFrame();
             mainFrame.setVisible();
             // etc.
        }
     };

     SwingUtilities.invokeLater(goVisible);

     // now the background init stuff
     Class.forName("com.yourcompany.view.Dialog1");
     Class.forName("com.yourcompany.view.WizardGUI");
     Class.forName("com.yourcompany.view.SecondaryFrame");

     // Here all the views are loaded and initialized
 }

Display blank main frame first and then load the rest of UI. You can use Swing Application Framework (or BSAF now) to init components and build layout when app is ready (main frame is visible) - Application.ready() method. Use http://code.google.com/p/jbusycomponent/ to show that app is loading...

There really is no good solution to this, it is one of the drawbacks of Java. That being said keep reading for my idea.

There are two parts to loading a class.

1. The JVM loads the class file into the ClassLoader when it is needed.
2. The JIT compiles and optimizes the code the first time the path is run.

You can do what rekin suggests, which is to eagerly load the UI classes before they are needed. That will only partially solve your problem, because you are only getting some of the classes. This will also have the disadvantage of taking up a lot more memory and even the classes in the class loader will be garbage collected if needed.

In order to avoid some of the hassles you are getting with the Reflection Approach. One method you could try is in your windows make sure the constructor does not display a window, instead have another method that would display the window called init(), Then have a separate Thread from main call create a new on each of the Windows you want to preload.
Do not save the reference to the window.

In the real code you would call the constructor and then init() for each window you wanted to display. This would give you the best possible scenario as far as performance, because now you are loading the classes as well as running the constructor code. Of course the size of the program in memory will be bloated.

public static void main(String [] args) {
    // Construct main Frame on Swing EDT thread
    Thread thread = new Thread() {
        public void run() {
          // now the background init stuff
          new com.yourcompany.view.Dialog1();
          new com.yourcompany.view.WizardGUI();
          new com.yourcompany.view.SecondaryFrame();
         // Here all the views are loaded and initialized
        }
     };

     JFrame mainFrame = new JFrame();
     mainFrame.setVisible();
     // etc.
 }

That's the goeal of having a Splash Screen(with or without a progress bar - much nicer with it, of course). You should show a nice splash to your users and then you initialize all your components starting with the main window on the EDT thread and at the end you show up your frame. Creating Swing components outside EDT might(it will sure do) create problems with visibility at least but also with concurrent access between your thread and EDT. DON'T do that, it's hard to detect these issues and it might manifest random on different hardware.

Of course, if you have a progress bar you need some free EDT time to render progress bar changes - actually even to refresh the splash screen itself(repainting the background image if another application blocked for a while your splash) you need free time on the EDT.

You should split your initializations in smaller blocks that will not take more than 500ms to run and you schedule them on the EDT with SwingUtilities.invokeLater.