Java JProgressBar不会通过setVisible显示（true）

Question

I have a method like below.

ProgressWindow is a sub class of JFrame containing JProgressBar .

addProgress() increments a value in the JProgressBar .

If I call this method from a method in another class, a frame of ProgressWindow will show up but not JProgressBar and some JLabels inside the frame. They show up after the last line ( System.out.println("finish") ).

If I call this method in a main method in the class containing this method, then every component (Bar, labels...) instantly shows up.

What can I do for showing the window correctly?

static void search(){
  ProgressWindow window = new ProgressWindow();
  window.setVisible(true);
  ExecutorService execs = Executors.newFixedThreadPool(Runtime
            .getRuntime().availableProcessors());
  Collection<Callable<Void>> processes = new LinkedList<>();
  for (int i = 0; i < 100; i++) {
    processes.add(new Callable<Void>() {
        @Override
        public Void call() throws Exception {
            progressWindow.addProgress(); // increment progress value
            return null;
        }
        });
    }
    try {
        execs.invokeAll(processes);
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        execs.shutdown();
    }
    System.out.println("finish");

Answer 1

Sounds like you what you're wanting to do is invoke the setVisible on the Swing UI thread, you can do this with invokeAndWait or invokeLater .

So something like:

final ProgressWindow window = new ProgressWindow();
SwingUtilities.invokeLater(new Runnable() {            
    @Override
    public void run() {
        window.setVisible(true);                
    }
});

Answer 2

The main problem is you seem to be calling search from the context of the Event Dispatching Thread.

The problem occurs because you are using execs.invokeAll which blocks until all the callables have finished running.

This means that the EDT is unable to process new events in Event Queue, including repaint events, this is why your UI is coming to a stand still...

There are a number of issues you are now going to face...

1. You should never update/modify a UI component from any thread other than the EDT
2. You should block the EDT for any reason
3. You seem to want to know when the search is complete, so you know need some kind of event notification...

The first thing we need is some way to be notified that the search has completed, this means you can no longer rely on search returning when the search is complete...

public interface SearchListener {
    public void searchCompleted();
}

Next we need an intermeditate search method that builds the UI and ensure that the search is launched within it's own Thread ...

static void search(final SearchListener listener) {
  final ProgressWindow window = new ProgressWindow();
  window.setVisible(true);

  Thread t = new Thread(new Runnable() {
    @Override
    public void run() {
        search(listener, window);
    }
  });
  t.start();
}

Then we need to modify the original search method to utilise the SearchListener interface to provide notification when the search is complete...

static void search(final SearchListener listener, final ProgressWindow window){
  ExecutorService execs = Executors.newFixedThreadPool(Runtime
            .getRuntime().availableProcessors());
  Collection<Callable<Void>> processes = new LinkedList<>();
  for (int i = 0; i < 100; i++) {
    processes.add(new Callable<Void>() {
        @Override
        public Void call() throws Exception {
            // This method needs to ensure that 
            // what ever it does to the UI, it is done from within
            // the context of the EDT!!
            progressWindow.addProgress();
            return null;
        }
        });
    }
    try {
        execs.invokeAll(processes);
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        execs.shutdown();
    }
    System.out.println("finish");
    SwingUtilities.invokeLater(new Runnable() {
        @Override
        public void run() {
            listener.searchCompleted();
        }
    });        
}

Now, without the source code for addProgress , I might be tempted to use

processes.add(new Callable<Void>() {
    @Override
    public Void call() throws Exception {
        SwingUtilities.invokeLater(new Runnable() {
            @Override
            public void run() {
                progressWindow.addProgress();
            }            
        });
        return null;
    }
    });
}

Instead...

Take a look at Concurrency in Swing for more details