Choisissez entre ExecutorService de soumettre et ExecutorService execute

exécuter: l'Utiliser pour le feu et oublier les appels

soumettre: l'Utiliser pour inspecter le résultat de l'appel de méthode et de prendre les mesures appropriées sur Future opposé retourné par l'appel

De la documentation javadoc

submit(Callable<T> task)

Présente une valeur de retour de tâches pour l'exécution et retourne un Avenir
qui représente les résultats en attente de la tâche.

Future<?> submit(Runnable task)

Soumet une tâche Exécutable pour l'exécution et renvoie un Futur représentant
de la tâche.

void execute(Runnable command)

Exécute la commande donnée à un certain moment dans l'avenir. La commande peut exécuter dans un nouveau fil de discussion, à un pool de thread, ou dans le thread appelant, à la discrétion de l'interprète de mise en œuvre.

Vous devez prendre des précautions lors de l'utilisation submit(). Il se cache exception dans le cadre lui-même, à moins que vous incorporez votre code de la tâche dans try{} catch{} bloc.

Exemple de code: Ce code avale Arithmetic exception : /by zero.

import java.util.concurrent.*;
import java.util.*;

public class ExecuteSubmitDemo{
    public ExecuteSubmitDemo()
    {
        System.out.println("creating service");
        ExecutorService service = Executors.newFixedThreadPool(10);
        //ExtendedExecutor service = new ExtendedExecutor();
        service.submit(new Runnable(){
                 public void run(){
                    int a=4, b = 0;
                    System.out.println("a and b="+a+":"+b);
                    System.out.println("a/b:"+(a/b));
                    System.out.println("Thread Name in Runnable after divide by zero:"+Thread.currentThread().getName());
                 }
            });
        service.shutdown();
    }
    public static void main(String args[]){
        ExecuteSubmitDemo demo = new ExecuteSubmitDemo();
    }
}

de sortie:

java ExecuteSubmitDemo
creating service
a and b=4:0

Même code lance par le remplacement de submit() avec execute() :

Remplacer

service.submit(new Runnable(){

avec

service.execute(new Runnable(){

de sortie:

java ExecuteSubmitDemo
creating service
a and b=4:0
Exception in thread "pool-1-thread-1" java.lang.ArithmeticException: / by zero
        at ExecuteSubmitDemo$1.run(ExecuteSubmitDemo.java:14)
        at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145)
        at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
        at java.lang.Thread.run(Thread.java:744)

Comment gérer ce type de scénarios en utilisant submit()?

1. Intégrer votre code de la Tâche ( Soit Praticable ou Remboursables par anticipation de la mise en œuvre) avec try{} catch{} bloc de code
2. Mettre en œuvre CustomThreadPoolExecutor

Nouvelle solution:

import java.util.concurrent.*;
import java.util.*;
public class ExecuteSubmitDemo{
public ExecuteSubmitDemo()
{
System.out.println("creating service");
//ExecutorService service = Executors.newFixedThreadPool(10);
ExtendedExecutor service = new ExtendedExecutor();
service.submit(new Runnable(){
public void run(){
int a=4, b = 0;
System.out.println("a and b="+a+":"+b);
System.out.println("a/b:"+(a/b));
System.out.println("Thread Name in Runnable after divide by zero:"+Thread.currentThread().getName());
}
});
service.shutdown();
}
public static void main(String args[]){
ExecuteSubmitDemo demo = new ExecuteSubmitDemo();
}
}
class ExtendedExecutor extends ThreadPoolExecutor {
public ExtendedExecutor() { 
super(1,1,60,TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(100));
}
//...
protected void afterExecute(Runnable r, Throwable t) {
super.afterExecute(r, t);
if (t == null && r instanceof Future<?>) {
try {
Object result = ((Future<?>) r).get();
} catch (CancellationException ce) {
t = ce;
} catch (ExecutionException ee) {
t = ee.getCause();
} catch (InterruptedException ie) {
Thread.currentThread().interrupt(); //ignore/reset
}
}
if (t != null)
System.out.println(t);
}
}

de sortie:

java ExecuteSubmitDemo
creating service
a and b=4:0
java.lang.ArithmeticException: / by zero

Prises à partir de la Javadoc:

Méthode submit s'étend de la base de la méthode {@link Exécuteur#execute} par la création et
de retour d'un {@link Futur} qui peut être utilisé pour annuler l'exécution et/ou attendre
achèvement.

Personnellement, je préfère l'utilisation de l'exécuter, car il se sent plus déclaratif, même si c'est vraiment une question de préférence personnelle.

De donner plus d'informations: dans le cas de la ExecutorService mise en œuvre, la mise en œuvre principales étant retournée par l'appel à Executors.newSingleThreadedExecutor() est un ThreadPoolExecutor.

La submit appels sont fournis par son parent AbstractExecutorService d'appel et exécuter en interne. exécuter est remplacée par/fourni par la ThreadPoolExecutor directement.

La réponse complète est une composition de deux réponses qui ont été publiés ici (plus un peu "extra"):

• Par la soumission d'une tâche (par rapport à l'exécution), vous obtenez en retour un avenir qui peut être utilisé pour obtenir le résultat ou d'annuler l'action. Vous n'avez pas ce genre de contrôle lorsque vous execute (parce que son type de retour id void)
• execute s'attend à un Runnable tout submit peut prendre soit un Runnable ou un Callable comme un argument (pour plus d'info à propos de la différence entre les deux - voir ci-dessous).
• execute des bulles tout décoché-exceptions tout de suite (il ne peut pas jeter checked exceptions!!!), alors que submit lie tout sorte d'exception à l'avenir qui retourne comme résultat, et que lorsque vous appelez future.get() un l' (emballée) exception sera levée . Le Throwable que vous obtiendrez est une instance de ExecutionException et si vous allez appeler cet objet getCause() il sera de retour l'original Throwable.

Un peu plus de (relative) points:

• Même si la tâche que vous souhaitez submit ne nécessite pas de retour d'un
  résultat, vous pouvez toujours utiliser Callable<Void> (au lieu d'utiliser un Runnable).
• L'annulation de tâches peut être fait à l'aide de la interruption mécanisme. Voici un exemple de la façon de mettre en œuvre une politique d'annulation

Pour résumer, il est préférable d'utiliser submit avec un Callable (vs execute avec un Runnable). Et je vais citer de "la Java de la simultanéité dans la pratique" Par Brian Goetz:

6.3.2 Résultat portant tâches: Callable et Avenir

L'Exécuteur framework utilise Exécutables comme sa tâche de base de la représentation. Praticable est assez
la limitation de l'abstraction; courir, ne peut retourner une valeur ou de jeter vérifié
les exceptions, même si elle peut avoir des effets secondaires tels que l'écriture d'un journal
fichier ou en plaçant un résultat dans une structure de données partagées. De nombreuses tâches sont
effectivement reportés calculs—l'exécution d'une requête de base de données, l'extraction de
une ressource sur le réseau, ou le calcul d'une fonction compliquée. Pour
ces types de tâches, Le mieux est encore de l'abstraction: il s'attend à ce
que le point d'entrée principal, appel, sera de retour une valeur et anticipe
qu'il peut lever une exception.7 Exécuteurs comprend plusieurs utilitaire
méthodes pour l'emballage d'autres types de tâches, y compris les Exécutables, et
java.de sécurité.PrivilegedAction, avec un Callable.