JProgressBar的一个框架

Frame:

package swing.progress;

import java.awt.BorderLayout;
import java.awt.Frame;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.List;
import java.util.concurrent.TimeUnit;

import javax.swing.JButton;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JProgressBar;
import javax.swing.SwingUtilities;
import javax.swing.SwingWorker;

/*2015-8-20*/
public class ProgressDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {

            @Override
            public void run() {
                ButtonFrame frame = new ButtonFrame();
                frame.setVisible(true);
                frame.setLocationRelativeTo(null);
            }
        });
    }

}

class ButtonFrame extends JFrame {
    private static final long serialVersionUID = -7304920642444493162L;
    public static final int DEFAULT_WIDTH = 400;
    public static final int DEFAULT_HEIGHT = 200;
    private JButton startButton;

    public ButtonFrame() {
        setTitle("ProgressBarTest");
        setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
        this.setDefaultCloseOperation(DISPOSE_ON_CLOSE);
        startButton = new JButton("Start");
        add(startButton, BorderLayout.CENTER);
        startButton.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {
                Processor processor = new TaskProcessor();
                ProgramDialog dialog = new ProgramDialog(ButtonFrame.this, processor);
                dialog.invokeProgress();
                dialog.setVisible(true);
                dialog.setLocationRelativeTo(null);
            }
        });
    }

}

JDialog:

class ProgramDialog extends JDialog {

    private static final long serialVersionUID = 130962873304185304L;
    private JProgressBar progressBar;
    private static final int DEFAULT_WIDTH = 200;
    private static final int DEFAULT_HEIGHT = 200;
    private Processor processor;

    public ProgramDialog(Frame owner, Processor processor) {
        super(owner, true);
        this.processor = processor;
        setTitle("JDialog Title");
        setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
        this.setLocationRelativeTo(null);
        progressBar = new JProgressBar(0, 100);
        // progressBar.setIndeterminate(true);
        add(progressBar, BorderLayout.CENTER);
        this.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
    }

    public void invokeProgress() {
        SimulatedActivity activity = new SimulatedActivity();
        activity.execute();
    }

    /**
     * <T> the result type returned by this SwingWorker's doInBackground and get
     * methods <V> the type used for carrying out intermediate results by this
     * SwingWorker's publish and process methods
     *
     * @author CY
     *
     */
    class SimulatedActivity extends SwingWorker<Void, Integer> {

        @Override
        protected Void doInBackground() throws Exception {
            publish(20);
            TimeUnit.SECONDS.sleep(1);
            publish(40);
            processor.doBusiness();
            publish(60);
            TimeUnit.SECONDS.sleep(2);
            publish(80);
            TimeUnit.SECONDS.sleep(1);
            publish(100);
            return null;
        }

        // Receives data chunks from the publish method asynchronously on the
        // Event Dispatch Thread.
        @Override
        protected void process(List<Integer> chunks) {
            System.out.println("process.Size:" + chunks.size());
            for (Integer chunk : chunks) {
                System.out.println(Thread.currentThread() + "process:" + chunk);
                progressBar.setValue(chunk);
            }
        }

        @Override
        protected void done() {
            ProgramDialog.this.dispose();
        }
    }

}

interface Processor {
    void doBusiness();
}

class TaskProcessor implements Processor {

    @Override
    public void doBusiness() {
        System.out.println("doBusiness");
    }

}

Output:

process.Size:1
Thread[AWT-EventQueue-0,6,main]process:20
doBusiness
process.Size:2
Thread[AWT-EventQueue-0,6,main]process:40
Thread[AWT-EventQueue-0,6,main]process:60
process.Size:1
Thread[AWT-EventQueue-0,6,main]process:80
process.Size:1
Thread[AWT-EventQueue-0,6,main]process:100

package swing.progress;

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.List;
import java.util.concurrent.TimeUnit;

import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JProgressBar;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.SwingUtilities;
import javax.swing.SwingWorker;

/*2015-7-6*/
public class ProgressBarTest {

    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {

            @Override
            public void run() {
                JFrame frame = new ProgressBarFrame();
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setVisible(true);
                frame.setLocationRelativeTo(null);

            }
        });
    }
}

class ProgressBarFrame extends JFrame {
    private static final long serialVersionUID = 1L;

    public static final int DEFAULT_WIDTH = 400;
    public static final int DEFAULT_HEIGHT = 200;

    private JButton startButton;
    private JProgressBar progressBar;
    private JCheckBox checkBox;
    private JTextArea textArea;
    private SimulatedActivity activity;

    public ProgressBarFrame() {
        setTitle("ProgressBarTest");
        setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
        textArea = new JTextArea();

        final int MAX = 1000;
        JPanel panel = new JPanel();
        startButton = new JButton("Start");
        progressBar = new JProgressBar(0, MAX);
        progressBar.setStringPainted(true);
        panel.add(startButton);
        panel.add(progressBar);

        checkBox = new JCheckBox("indeterminate");
        checkBox.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {
                progressBar.setIndeterminate(checkBox.isSelected());
                progressBar.setStringPainted(!progressBar.isIndeterminate());
            }
        });

        panel.add(checkBox);
        add(new JScrollPane(textArea), BorderLayout.CENTER);
        add(panel, BorderLayout.SOUTH);

        startButton.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {
                startButton.setEnabled(false);
                activity = new SimulatedActivity(MAX);
                activity.execute();
            }
        });

    }

    /**
     * <T> the result type returned by this SwingWorker's doInBackground and get  methods
     * <V> the type used for carrying out intermediate results by this
     * SwingWorker's publish and process methods
     *
     * @author CY
     *
     */
    class SimulatedActivity extends SwingWorker<Void, Integer> {

        private int current;
        private int target;

        public SimulatedActivity(int target) {
            super();
            current = 0;
            this.target = target;
        }

        @Override
        protected Void doInBackground() throws Exception {
            while (current < target) {
                TimeUnit.SECONDS.sleep(1);
                current++;
                publish(current);
                System.out.println(Thread.currentThread()+"publish:" + current);
            }
            return null;
        }

        // Receives data chunks from the publish method asynchronously on the Event Dispatch Thread.
        @Override
        protected void process(List<Integer> chunks) {
            System.out.println("process.Size:" + chunks.size());
            for (Integer chunk : chunks) {
                textArea.append(chunk + "\n");
                System.out.println(Thread.currentThread()+"process:" + chunk);
                progressBar.setValue(chunk);
            }
        }

        @Override
        protected void done() {
            startButton.setEnabled(true);
        }

    }

}

print:

Thread[SwingWorker-pool-1-thread-1,5,main]publish:1
process.Size:1
Thread[AWT-EventQueue-0,6,main]process:1
Thread[SwingWorker-pool-1-thread-1,5,main]publish:2
process.Size:1
Thread[AWT-EventQueue-0,6,main]process:2
Thread[SwingWorker-pool-1-thread-1,5,main]publish:3
process.Size:1
Thread[AWT-EventQueue-0,6,main]process:3
Thread[SwingWorker-pool-1-thread-1,5,main]publish:4
process.Size:1
Thread[AWT-EventQueue-0,6,main]process:4
Thread[SwingWorker-pool-1-thread-1,5,main]publish:5
process.Size:1
Thread[AWT-EventQueue-0,6,main]process:5
Thread[SwingWorker-pool-1-thread-1,5,main]publish:6
process.Size:1
Thread[AWT-EventQueue-0,6,main]process:6
Thread[SwingWorker-pool-1-thread-1,5,main]publish:7
process.Size:1
Thread[AWT-EventQueue-0,6,main]process:7
Thread[SwingWorker-pool-1-thread-1,5,main]publish:8
process.Size:1
Thread[AWT-EventQueue-0,6,main]process:8

Tips:

javax.swing.SwingWorker<List<Integer>, Integer>

An abstract class to perform lengthy GUI-interacting tasks in a dedicated thread. 

When writing a multi-threaded application using Swing, there are two constraints to keep in mind: (refer to How to Use Threads for more details): 

Time-consuming tasks should not be run on the Event Dispatch Thread. Otherwise the application becomes unresponsive.
Swing components should be accessed on the Event Dispatch Thread only. 

These constraints mean that a GUI application with time intensive computing needs at least two threads: 1) a thread to perform the lengthy task and 2) the Event Dispatch Thread (EDT) for all GUI-related activities. This involves inter-thread communication which can be tricky to implement. 

SwingWorker is designed for situations where you need to have a long running task run in a background thread and provide updates to the UI either when done, or while processing. Subclasses of SwingWorker must implement the doInBackground method to perform the background computation. 

Workflow 

There are three threads involved in the life cycle of a SwingWorker : 

Current thread: The execute method is called on this thread. It schedules SwingWorker for the execution on a worker thread and returns immediately. One can wait for the SwingWorker to complete using the get methods. 

Worker thread: The doInBackground method is called on this thread. This is where all background activities should happen. To notify PropertyChangeListeners about bound properties changes use the firePropertyChange and getPropertyChangeSupport methods. By default there are two bound properties available: state and progress. 

Event Dispatch Thread: All Swing related activities occur on this thread. SwingWorker invokes the process and done methods and notifies any PropertyChangeListeners on this thread. 

Often, the Current thread is the Event Dispatch Thread. 

Before the doInBackground method is invoked on a worker thread, SwingWorker notifies any PropertyChangeListeners about the state property change to StateValue.STARTED. After the doInBackground method is finished the done method is executed. Then SwingWorker notifies any PropertyChangeListeners about the state property change to StateValue.DONE. 

SwingWorker is only designed to be executed once. Executing a SwingWorker more than once will not result in invoking the doInBackground method twice. 

Sample Usage 

The following example illustrates the simplest use case. Some processing is done in the background and when done you update a Swing component. 

Say we want to find the "Meaning of Life" and display the result in a JLabel. 

   final JLabel label;
   class MeaningOfLifeFinder extends SwingWorker<String, Object> {
       @Override
       public String doInBackground() {
           return findTheMeaningOfLife();
       }

       @Override
       protected void done() {
           try {
               label.setText(get());
           } catch (Exception ignore) {
           }
       }
   }

   (new MeaningOfLifeFinder()).execute();

The next example is useful in situations where you wish to process data as it is ready on the Event Dispatch Thread. 

Now we want to find the first N prime numbers and display the results in a JTextArea. While this is computing, we want to update our progress in a JProgressBar. Finally, we also want to print the prime numbers to System.out. 

 class PrimeNumbersTask extends
         SwingWorker<List<Integer>, Integer> {
     PrimeNumbersTask(JTextArea textArea, int numbersToFind) {
         //initialize
     }

     @Override
     public List<Integer> doInBackground() {
         while (! enough && ! isCancelled()) {
                 number = nextPrimeNumber();
                 publish(number);
                 setProgress(100 * numbers.size() / numbersToFind);
             }
         }
         return numbers;
     }

     @Override
     protected void process(List<Integer> chunks) {
         for (int number : chunks) {
             textArea.append(number + "\n");
         }
     }
 }

 JTextArea textArea = new JTextArea();
 final JProgressBar progressBar = new JProgressBar(0, 100);
 PrimeNumbersTask task = new PrimeNumbersTask(textArea, N);
 task.addPropertyChangeListener(
     new PropertyChangeListener() {
         public  void propertyChange(PropertyChangeEvent evt) {
             if ("progress".equals(evt.getPropertyName())) {
                 progressBar.setValue((Integer)evt.getNewValue());
             }
         }
     });

 task.execute();
 System.out.println(task.get()); //prints all prime numbers we have got

Because SwingWorker implements Runnable, a SwingWorker can be submitted to an java.util.concurrent.Executor for execution.

Parameters:
<T> the result type returned by this SwingWorker's doInBackground and get methods
<V> the type used for carrying out intermediate results by this SwingWorker's publish and process methods

void swing.progress.ProgressBarFrame.SimulatedActivity.process(List<Integer>
chunks):
Receives data chunks from the publish method asynchronously on the Event Dispatch Thread.
Please refer to the publish method for more details.