Differenza tra Executor ed ExecutorCompletionservice in java

Question

Come indica il titolo della domanda, qual è la differenza tra le classi Executors ed ExecutorCompletionService in java?

Sono nuovo al threading, quindi se qualcuno può spiegare con un pezzo di codice, sarebbe di grande aiuto.

Answer 1

Supponete di avere una serie di compiti A, B, C, D, E e si desidera eseguire ciascuna di esse in modo asincrono in un Executor ed elaborare i risultati 1 da 1 come completano.

Con una Executor, si dovrebbe farlo in questo modo:

List<Future<?>> futures = new ArrayList<Future<?>>(); 
futures.add(executorService.submit(A)); 
futures.add(executorService.submit(B)); 
futures.add(executorService.submit(C)); 
futures.add(executorService.submit(D)); 
futures.add(executorService.submit(E)); 

//This loop must process the tasks in the order they were submitted: A, B, C, D, E 
for (Future<?> future:futures) { 
    ? result = future.get(); 
    // Some processing here 
} 

Il problema di questo metodo è che non v'è alcuna garanzia che il compito A completerà prima. Pertanto, è possibile che il thread principale stia bloccando oziosamente in attesa che l'attività A si completi quando potrebbe elaborare il risultato di un'altra attività (ad esempio, attività B). La latenza di elaborazione dei risultati potrebbe essere ridotta utilizzando ExecutorCompletionService.

List<Future<?>> futures = new ArrayList<Future<?>>(); 
futures.add(executorCompletionService.submit(A)); 
futures.add(executorCompletionService.submit(B)); 
futures.add(executorCompletionService.submit(C)); 
futures.add(executorCompletionService.submit(D)); 
futures.add(executorCompletionService.submit(E)); 

//This for loop will process the tasks in the order they are completed, 
//regardless of submission order 
for (int i=0; i<futures.size(); i++) { 
    ? result = executorCompletionService.take().get(); 
    // Some processing here 
} 

Quindi, in sostanza, ExecutorCompletionService potrebbero essere utilizzati per spremere un po 'di più l'efficienza quando l'ordine dei risultati delle attività di trasformazione non ha importanza.

Una cosa importante da notare però. L'implementazione di ExecutorCompletionService contiene una coda di risultati. Se take o poll non vengono chiamati per il drenaggio di tale coda, si verificherà una perdita di memoria. Alcune persone usano il Future restituito da submit per elaborare i risultati e questo NON è l'utilizzo corretto.

Answer 2

Un ExecutorCompletionService si sovrapporrà e delegherà semplicemente a un normale Executor e offrirà metodi convenienti per recuperare le attività completate più di recente.

l'API ha alcuni esempi che dovrebbero farti andare

http://download.oracle.com/javase/1,5.0/docs/api/java/util/concurrent/ExecutorCompletionService.html