SwingWorker

public abstract class SwingWorker<T, V> implements RunnableFuture<T> {  
    //FutureTask  
    private final FutureTask<T> future;  
    public final void run() {  
        future.run();  
    }  
  
    public SwingWorker() {  
        Callable<T> callable =   
                new Callable<T>() {  
//1. 任务线程一创建就处于PENDING状态  
                    public T call() throws Exception {  
//2. 当doInBackground方法开始时，任务线程就进入STARTED状态  
                    setState(StateValue.STARTED);    
                        return doInBackground();  
                    }  
                };  
  
        //FutureTask  
        future = new FutureTask<T>(callable) {  
  
                       @Override  
                       protected void done() {  
                           doneEDT();  
//3. 当doInBackground方法完成后，任务线程就处于DONE状态  
                           setState(StateValue.DONE);   
                       }  
                   };  
  
       state = StateValue.PENDING;  
       propertyChangeSupport = new SwingWorkerPropertyChangeSupport(this);  
       doProcess = null;  
       doNotifyProgressChange = null;  
    }  
  
}  

//1、doInBackground  
protected abstract T doInBackground() throws Exception ;  
//2、get --不可重写  
public final T get() throws InterruptedException, ExecutionException {  
    return future.get();  
}  
//3、done  
protected void done() {  
}  
  
  
/** 
 * Invokes {@code done} on the EDT. 
 */  
private void doneEDT() {  
    Runnable doDone =   
        new Runnable() {  
            public void run() {  
                done();  
            }  
        };   
    //SwingWorker在EDT上激活done()  
    if (SwingUtilities.isEventDispatchThread()) {   
        doDone.run();  
    } else {  
        doSubmit.add(doDone);  
    }  
}  

SwingWorker testWorker = new SwingWorker<Icon , Void>(){  
      @Override  
       protected Icon doInBackground() throws Exception {  
        Icon icon = retrieveImage(strImageUrl);   
            return icon;   
       }   
  
       protected void done(){   
       //没有必要用invokeLater！因为done()本身是在EDT中执行的   
           SwingUtilities.invokeLater(new Runnable(){   
            @Override   
            public void run() {  
            Icon icon= get();  
                        lblImage.setIcon(icon); //lblImage可通过构造函数传入  
                }             
}  
//execute方法是异步执行，它立即返回到调用者。在execute方法执行后，EDT立即继续执行  
testWorker.execute();  

   
//SwingWorker.publish  
   protected final void publish(V... chunks) {  
        synchronized (this) {  
            if (doProcess == null) {  
                doProcess = new AccumulativeRunnable<V>() {  
                    @Override  
                    public void run(List<V> args) {  
                        //调用process  
                        process(args);   
                    }  
                    @Override  
                    protected void submit() {  
                        doSubmit.add(this);  
                    }  
                };  
            }  
        }  
        doProcess.add(chunks);  
    }  
  
    //SwingWorker.process 在EDT中调用  
    protected void process(List<V> chunks) {  
    }  

private void retrieveAndProcessThumbnails(List<ImageInfo> infoList) {  
  for (int x=0; x <infoList.size() && !isCancelled(); ++x) {             
    ImageInfo info = infoList.get(x);  
    String strImageUrl = String.format("%s/%s/%s_%s_s.jpg",  
    IMAGE_URL, info.getServer(), info.getId(), info.getSecret());  
    Icon thumbNail = retrieveThumbNail(strImageUrl);  
    info.setThumbnail(thumbNail);  
    //发布中间结果  
    publish(info);   
    setProgress(100 * (x+1)/infoList.size());  
  }  
}     
/** 
 * Process is called as a result of this worker thread‘s calling the 
 * publish method. This method runs on the event dispatch thread. 
 * 
 * As image thumbnails are retrieved, the worker adds them to the 
 * list model. 
 * 
 */  
@Override  
protected void process(List<ImageInfo> infoList) {  
  for(ImageInfo info: infoList) {  
    if (isCancelled()) { //见下节  
      break;  
    }  
    //处理中间结果  
    model.addElement(info);  
  }       
}  

public final boolean cancel(boolean mayInterruptIfRunning) {  
    return future.cancel(mayInterruptIfRunning);  
}  
  
/** 
 * {@inheritDoc} 
 */  
public final boolean isCancelled() {  
    return future.isCancelled();  
}  

private void searchImages(String strSearchText, int page) {  
  
  if (searcher != null && !searcher.isDone()) {  
    // Cancel current search to begin a new one.  
    // You want only one image search at a time.  
    //检查现有线程是否正在运行，如果正在运行则调用cancel来取消  
    searcher.cancel(true);  
    searcher = null;  
  }  
  ...  
  // Provide the list model so that the ImageSearcher can publish  
  // images to the list immediately as they are available.  
  searcher = new ImageSearcher(listModel, API_KEY, strEncodedText, page);  
  searcher.addPropertyChangeListener(listenerMatchedImages);  
  progressMatchedImages.setIndeterminate(true);  
  // Start the search!  
  searcher.execute();  
  // This event thread continues immediately here without blocking.  
}   

//javax.imageio.ImageReader reader  
  
reader.addIIOReadProgressListener(new IIOReadProgressListener() {  
  ...             
  public void imageProgress(ImageReader source, float percentageDone) {  
    setProgress((int) percentageDone);  
  }  
  public void imageComplete(ImageReader source) {  
    setProgress(100);  
  }  
});   

/** 
 * ProgressListener listens to "progress" property changes  
   in the SwingWorkers that search and load images. 
 */  
class ProgressListener implements PropertyChangeListener {  
  // Prevent creation without providing a progress bar.  
  private ProgressListener() {}    
  ProgressListener(JProgressBar progressBar) {  
    this.progressBar = progressBar;  
    this.progressBar.setValue(0);  
  }    
  public void propertyChange(PropertyChangeEvent evt) {  
    String strPropertyName = evt.getPropertyName();  
    if ("progress".equals(strPropertyName)) {  
      progressBar.setIndeterminate(false);  
      int progress = (Integer)evt.getNewValue();  
      progressBar.setValue(progress);  
    }  
  }    
  private JProgressBar progressBar;  
}   

private void listImagesValueChanged(ListSelectionEvent evt) {  
  ...  
  ImageInfo info = (ImageInfo) listImages.getSelectedValue();  
  String id = info.getId();  
  String server = info.getServer();  
  String secret = info.getSecret();  
  // No need to search an invalid thumbnail image  
  if (id == null || server == null || secret == null) {  
    return;  
  }  
  String strImageUrl = String.format(IMAGE_URL_FORMAT, server, id, secret);  
  retrieveImage(strImageUrl);  
  ...  
}      
private void retrieveImage(String imageUrl) {  
  // SwingWorker，不可复用  
  ImageRetriever imgRetriever = new ImageRetriever(lblImage, imageUrl);  
  progressSelectedImage.setValue(0);  
  // Listen for changes in the "progress" property.  
  // You can reuse the listener even though the worker thread will be a new SwingWorker.  
  imgRetriever.addPropertyChangeListener(listenerSelectedImage);    
  progressSelectedImage.setIndeterminate(true);    
  // Tell the worker thread to begin with this asynchronous method.  
  imgRetriever.execute();  
  // This event thread continues immediately here without blocking.    
}