Quand dois-je utiliser un CompletionService sur un ExecutorService?

Je viens de trouver CompletionService dans ce blog. Cependant, ce n'est pas vraiment présente les avantages de CompletionService sur une norme ExecutorService. Le même code peut être écrit avec les deux. Donc, quand on est un CompletionService utile?

Pouvez-vous donner un court exemple de code pour faire ce cristal clair? Par exemple, cet exemple de code montre où un CompletionService n'est pas nécessaire (=équivalent à ExecutorService)

    ExecutorService taskExecutor = Executors.newCachedThreadPool();
    //       CompletionService<Long> taskCompletionService =
    //               new ExecutorCompletionService<Long>(taskExecutor);
    Callable<Long> callable = new Callable<Long>() {
        @Override
        public Long call() throws Exception {
            return 1L;
        }
    };

    Future<Long> future = //taskCompletionService.submit(callable);
        taskExecutor.submit(callable);

    while (!future.isDone()) {
        //Do some work...
        System.out.println("Working on something...");
    }
    try {
        System.out.println(future.get());
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (ExecutionException e) {
        e.printStackTrace();
    }

InformationsquelleAutor ripper234 | 2011-02-06

Avec ExecutorService, une fois que vous avez soumis les tâches à exécuter, vous devez coder manuellement efficacement pour obtenir les résultats des tâches accomplies.

Avec CompletionService, c'est à peu près automatisé. La différence n'est pas très évidente dans le code que vous avez présenté, parce que vous soumettez à une seule tâche. Cependant, imaginez que vous avez une liste de tâches à être soumis. Dans l'exemple ci-dessous, plusieurs tâches sont soumis à la CompletionService. Alors, au lieu d'essayer de savoir quelle tâche est terminée (pour obtenir les résultats), il demande juste le CompletionService exemple pour renvoyer les résultats à mesure qu'ils deviennent disponibles.

public class CompletionServiceTest {
class CalcResult {
long result ;
CalcResult(long l) {
result = l;
}
}
class CallableTask implements Callable<CalcResult> {
String taskName ;
long  input1 ;
int input2 ;
CallableTask(String name , long v1 , int v2 ) {
taskName = name;
input1 = v1;
input2 = v2 ;
}
public CalcResult call() throws Exception {
System.out.println(" Task " + taskName + " Started -----");
for(int i=0;i<input2 ;i++) {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
System.out.println(" Task " + taskName + " Interrupted !! ");
e.printStackTrace();
}
input1 += i;
}
System.out.println(" Task " + taskName + " Completed @@@@@@");
return new CalcResult(input1) ;
}
}
public void test(){
ExecutorService taskExecutor = Executors.newFixedThreadPool(3);
CompletionService<CalcResult> taskCompletionService = new ExecutorCompletionService<CalcResult>(taskExecutor);
int submittedTasks = 5;
for (int i=0;i< submittedTasks;i++) {
taskCompletionService.submit(new CallableTask (
String.valueOf(i), 
(i * 10), 
((i * 10) + 10  )
));
System.out.println("Task " + String.valueOf(i) + "subitted");
}
for (int tasksHandled=0;tasksHandled<submittedTasks;tasksHandled++) {
try {
System.out.println("trying to take from Completion service");
Future<CalcResult> result = taskCompletionService.take();
System.out.println("result for a task availble in queue.Trying to get()");
//above call blocks till atleast one task is completed and results availble for it
//but we dont have to worry which one
//process the result here by doing result.get()
CalcResult l = result.get();
System.out.println("Task " + String.valueOf(tasksHandled) + "Completed - results obtained : " + String.valueOf(l.result));
} catch (InterruptedException e) {
//Something went wrong with a task submitted
System.out.println("Error Interrupted exception");
e.printStackTrace();
} catch (ExecutionException e) {
//Something went wrong with the result
e.printStackTrace();
System.out.println("Error get() threw exception");
}
}
}
}

pour un autre exemple, voir Java Simultanéité, dans la Pratique, pg. 130. Il y a un CompletionService est utilisé pour le rendu des images qu'ils seront disponibles.
Sûr de supposer take et poll sur CompletionService sont thread-safe? Dans votre exemple, les tâches sont toujours en cours d'exécution lors de la première invoquer take(), et je ne vois pas du tout explicite de la synchronisation.
take() est en effet thread-safe. Vous pouvez le lire dans la Javadoc, mais, fondamentalement, take() va attendre la prochaine terminé résultat et puis retour. Le CompletionService fonctionne avec un BlockingQueue pour la sortie.
est-il une meilleure façon de savoir quand ExecutorCompletionService a terminé toutes les tâches, plutôt que de comptabiliser le nombre de tâches?

InformationsquelleAutor Bhaskar

144

En omettant de nombreux détails:
- ExecutorService = file d'attente entrante + threads de travail
- CompletionService = file d'attente entrante + threads + file d'attente de sortie
InformationsquelleAutor Alex Miller
10

Je pense que la javadoc meilleures réponses à la question de savoir quand la CompletionService est utile dans un façon une ExecutorService ne l'est pas.

Un service qui découple la production de nouvelles tâches asynchrones à partir de la consommation des résultats des tâches accomplies.

Fondamentalement, cette interface permet à un programme de disposer de producteurs qui créer et soumettre des tâches (et même examiner les résultats de ces moyens) sans savoir à propos de tous les autres consommateurs, les résultats de ces tâches. Pendant ce temps, les consommateurs qui sont conscients de la CompletionService pourrait poll ou take résultats sans être au courant des producteurs de soumettre les tâches.

Pour l'enregistrement, et j'ai peut-être tort, car il est un peu tard, mais je suis assez certain que le code d'exemple dans ce billet de blog provoque une fuite de mémoire. Sans un consommateur actif prenant les résultats de la ExecutorCompletionServiceinternes de la file d'attente, je ne suis pas sûr de savoir comment le blogueur attend à ce que la file d'attente à l'égout.

InformationsquelleAutor Tim Bender
10

Fondamentalement, vous utilisez un CompletionService si vous voulez exécuter plusieurs tâches en parallèle, et ensuite travailler avec eux dans leurs achèvement de la commande. Donc, si j'execute 5 emplois, la CompletionService me donnera la première que cela se termine. L'exemple où il n'existe qu'une seule tâche ne confère aucune valeur supplémentaire sur une Executor outre la possibilité de soumettre un Callable.

InformationsquelleAutor Jed Wesley-Smith

Tout d'abord, si nous ne voulez pas gaspiller de temps processeur, nous n'utiliserons pas

while (!future.isDone()) {
//Do some work...
}

Nous devons utiliser

service.shutdown();
service.awaitTermination(14, TimeUnit.DAYS);

La mauvaise chose à propos de ce code est qu'il va fermer ExecutorService. Si nous voulons continuer à travailler avec elle (c'est à dire que nous avons une certaine recursicve la création de la tâche), nous avons deux solutions: invokeAll ou ExecutorService.

invokeAll va attendre jusqu'à ce que tous les tâches à remplir. ExecutorService nous donne la capacité de prendre ou de résultats d'un sondage, un par un.

Et, finily, récursive exemple:

ExecutorService executorService = Executors.newFixedThreadPool(THREAD_NUMBER);
ExecutorCompletionService<String> completionService = new ExecutorCompletionService<String>(executorService);
while (Tasks.size() > 0) {
for (final Task task : Tasks) {
completionService.submit(new Callable<String>() {   
@Override
public String call() throws Exception {
return DoTask(task);
}
});
} 
try {                   
int taskNum = Tasks.size();
Tasks.clear();
for (int i = 0; i < taskNum; ++i) {
Result result = completionService.take().get();
if (result != null)
Tasks.add(result.toTask());
}           
} catch (InterruptedException e) {
// error :(
} catch (ExecutionException e) {
// error :(
}
}

InformationsquelleAutor Sklavit

1

Voir par vous-même au moment de l'exécution,essayez de mettre en œuvre des solutions (Executorservice et Completionservice) et vous verrez comment les différents qu'ils se comportent et ce sera plus clair quand utiliser l'un ou l'autre.
Il y a un exemple ici si vous voulez http://rdafbn.blogspot.co.uk/2013/01/executorservice-vs-completionservice-vs.html

InformationsquelleAutor marcocast
1

Disons que vous avez 5 long de la tâche en cours d'exécution(callable tâche) et que vous avez soumis ces tâches à l'exécuteur de service. Maintenant, imaginez que vous ne voulez pas attendre pour l'ensemble des 5 tâche de concourir au lieu de cela, vous voulez faire une sorte de traitement de ces tâches si tout se termine. Maintenant, cela peut être fait soit par écrit logique d'interrogation sur l'avenir des objets ou de l'utilisation de cette API.

InformationsquelleAutor Bikas Katwal

il est un autre avantage de l'utilisation de completionservice: Performance

lorsque vous appelez future.get(), vous êtes spin attente:

de java.util.concurrent.CompletableFuture

  private Object waitingGet(boolean interruptible) {
Signaller q = null;
boolean queued = false;
int spins = -1;
Object r;
while ((r = result) == null) {
if (spins < 0)
spins = (Runtime.getRuntime().availableProcessors() > 1) ?
1 << 8 : 0; //Use brief spin-wait on multiprocessors
else if (spins > 0) {
if (ThreadLocalRandom.nextSecondarySeed() >= 0)
--spins;
}

quand vous avez un travail de longue haleine, ce sera une catastrophe pour la performance.

avec completionservice, une fois que la tâche est terminée, il est le résultat sera mis en attente et vous pouvez interrogation de la file d'attente à faible rendement plat.

completionservice y parvenir en utilisant l'écharpe tâche avec une done crochet.

java.util.concurrent.ExecutorCompletionService

    private class QueueingFuture extends FutureTask<Void> {
QueueingFuture(RunnableFuture<V> task) {
super(task, null);
this.task = task;
}
protected void done() { completionQueue.add(task); }
private final Future<V> task;
}

InformationsquelleAutor 宏杰李

0

Si la tâche du producteur n'est pas intéressé par les résultats et il est une autre composante de la responsabilité pour les résultats du processus de tâche asynchrone exécuté par l'exécuteur de service, alors vous devriez utiliser CompletionService. Il vous aide dans la séparation des tâches résultat processeur de la tâche de producteur. Voir l'exemple http://www.zoftino.com/java-concurrency-executors-framework-tutorial

InformationsquelleAutor Arnav Rao
0
```
package com.barcap.test.test00;
import java.util.concurrent.*;
/**
* Created by Sony on 25-04-2019.
*/
public class ExecutorCompletest00 {
public static void main(String[] args) {
ExecutorService exc= Executors.newFixedThreadPool( 10 );
ExecutorCompletionService executorCompletionService= new ExecutorCompletionService( exc );
for (int i=1;i<10;i++){
Task00 task00= new Task00( i );
executorCompletionService.submit( task00 );
}
for (int i=1;i<20;i++){
try {
Future<Integer> future= (Future <Integer>) executorCompletionService.take();
Integer inttest=future.get();
System.out.println(" the result of completion service is "+inttest);
break;
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
}
```
=======================================================
```
package com.barcap.test.test00;
import java.util.*;
import java.util.concurrent.*;
/**
* Created by Sony on 25-04-2019.
*/
public class ExecutorServ00 {
public static void main(String[] args) {
ExecutorService executorService=Executors.newFixedThreadPool( 9 );
List<Future> futList= new ArrayList <>(  );
for (int i=1;i<10;i++) {
Future result= executorService.submit( new Task00( i ) );
futList.add( result );
}
for (Future<Integer> futureEach :futList ){
try {
Integer inm=   futureEach.get();
System.out.println("the result of future executorservice is "+inm);
break;
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
}
```
===========================================================
```
package com.barcap.test.test00;
import java.util.concurrent.*;
/**
* Created by Sony on 25-04-2019.
*/
public class Task00 implements Callable<Integer> {
int i;
public Task00(int i) {
this.i = i;
}
@Override
public Integer call() throws Exception {
System.out.println(" the current thread is "+Thread.currentThread().getName()  +" the result should be "+i);
int sleepforsec=100000/i;
Thread.sleep( sleepforsec );
System.out.println(" the task complted for "+Thread.currentThread().getName()  +" the result should be "+i);
return i;
}
}
```
======================================================================

différence de journaux pour exécuteur testamentaire de l'achèvement du service:
le thread courant est pool-1-thread-1, le résultat devrait être de 1
le thread courant est pool-1-thread-2 le résultat devrait être de 2
le thread courant est pool-1-thread-3 le résultat devrait être de 3
le thread courant est pool-1-thread-4 le résultat devrait être de 4
le thread courant est pool-1-thread-6 le résultat devrait être de 6
le thread courant est pool-1-thread-5 le résultat doit être de 5
le thread courant est pool-1-thread-7 le résultat devrait être de 7
le thread courant est pool-1-thread-9 le résultat doit être de 9
le thread courant est pool-1-thread-8 le résultat devrait être de 8
la tâche complted pour pool-1-thread-9 le résultat doit être de 9
le résultat est 9
la tâche complted pour pool-1-thread-8 le résultat devrait être de 8
la tâche complted pour pool-1-thread-7 le résultat devrait être de 7
la tâche complted pour pool-1-thread-6 le résultat devrait être de 6
la tâche complted pour pool-1-thread-5 le résultat doit être de 5
la tâche complted pour pool-1-thread-4 le résultat devrait être de 4
la tâche complted pour pool-1-thread-3 le résultat devrait être de 3

la tâche complted pour pool-1-thread-2 le résultat devrait être de 2

le thread courant est pool-1-thread-1, le résultat devrait être de 1
le thread courant est pool-1-thread-3 le résultat devrait être de 3
le thread courant est pool-1-thread-2 le résultat devrait être de 2
le thread courant est pool-1-thread-5 le résultat doit être de 5
le thread courant est pool-1-thread-4 le résultat devrait être de 4
le thread courant est pool-1-thread-6 le résultat devrait être de 6
le thread courant est pool-1-thread-7 le résultat devrait être de 7
le thread courant est pool-1-thread-8 le résultat devrait être de 8
le thread courant est pool-1-thread-9 le résultat doit être de 9
la tâche complted pour pool-1-thread-9 le résultat doit être de 9
la tâche complted pour pool-1-thread-8 le résultat devrait être de 8
la tâche complted pour pool-1-thread-7 le résultat devrait être de 7
la tâche complted pour pool-1-thread-6 le résultat devrait être de 6
la tâche complted pour pool-1-thread-5 le résultat doit être de 5
la tâche complted pour pool-1-thread-4 le résultat devrait être de 4
la tâche complted pour pool-1-thread-3 le résultat devrait être de 3
la tâche complted pour pool-1-thread-2 le résultat devrait être de 2
la tâche complted pour pool-1-thread-1, le résultat devrait être de 1
le résultat de l'avenir est 1

=======================================================

pour executorservice le résultat ne sera disponible une fois toutes les tâches complted.

exécuteur completionservice aucun résultat disponible faire ce retour.

InformationsquelleAutor Prasad

Vous devez vous connecter pour publier un commentaire.

la tâche complted pour pool-1-thread-2 le résultat devrait être de 2