Esecuzione di un ExecutorService all'interno di SwingWorker è una buona pratica?

Question

Considerate seguente codice:

 SwingWorker<Void, Void> sworker = new SwingWorker<Void, Void>() { 

     @Override 
     protected Void doInBackground() throws Exception { 
      ExecutorService executor = Executors.newFixedThreadPool(5); 
      try { 
       for (int j = 0; j < 5; j++) { 
        Callable<Object> worker = new MyCallableImpl(); 
        Future<Object> future = executor.submit(worker); 
        array[j] = future.get(); 
       } 
      } catch (InterruptedException e) { 
       // some code here 
      } catch (ExecutionException e) { 
       // some code here 
      } 
       // some code here 
      executor.shutdown(); 
      return null; 
     } 

    }; 
    sworker.execute(); 

Come ho detto nel titolo: si tratta di una buona pratica per invocare ExecutorService all'interno doInBackground() metodo di SwingWorker? Funziona per me (JDK1.7), la GUI non è bloccata e più thread dal pool Executor sono in esecuzione in background, ma ho ancora qualche dubbio ...

Answer 1

Il codice di cui sopra non ha molto senso per me.

Se l'obiettivo è garantire che la GUI resti reattiva mentre è in esecuzione un'attività di lunga durata, non è necessario utilizzare lo ExecutorService poiché il meccanismo fornisce già tale meccanismo.

Answer 2

Per ulteriore risposta di mre. Non ha senso perché la tua esecuzione è in realtà a thread singolo. Il doInBackground si invierà all'esecutore e attenderà il completamento di quella singola attività, quindi invierà un altro.

È necessario inviare allo stesso modo, ma memorizzare gli Future s restituiti in un elenco di un certo tipo, quindi ottenere ciascuno di essi dopo che tutte le attività sono state inviate.

Non mi interessa il doInBackground inviare questi lavori in modo asincrono come fa mre. Se stai provando a inviare un numero di attività e hai solo N inviato in un dato momento, non dovresti assolutamente farlo tramite SwingWorker.doInBackground. Usando un ExectorService + SwingUtilities.invokeLater penso sia il modo migliore.

E per chiarire qualsiasi confusione, lo invokeLater deve essere utilizzato solo qui quando l'attività all'interno di ExecutorService è completa e tutto ciò che deve fare è aggiornare il componente dell'interfaccia utente.

Edit: Esempio per affrontare il tuo commento

protected Void doInBackground() throws Exception { 
    ExecutorService executor = Executors.newFixedThreadPool(5); 
    List<Future> futures = ...; 
    try { 
     for (int j = 0; j < 5; j++) { 
      Callable<Object> worker = new MyCallableImpl(); 
      futures.add(executor.submit(new Callable<Object>(){ 
       public Object call(){ 
        //expensive time consuming operation 
        final String result = ...;//result from consuming operation 
        SwingUtilities.invokeLater(new Runnable(){ 
         public void run(){ 
          jLabel.setText(result); 
         } 
        }); 
        return new Object(); 
       } 
      )); 
     } 
     for(Future<Object> f :futures)f.get(); 
     executor.shutdown(); 
    return null; 
} 

Notate come il invokeLater è fatto per fare un semplice aggiornamento? Questo non dovrebbe causare il blocco dell'EDT.

Answer 3

• può eseguire SwingWorkers esempio dalla esecutore

• devono accettare che esecutore non si preoccupa SwingWorkers ciclo di vita e viceversa

• necessario implementare PropertyChangeListener per SwingWorker

• exmple here