Quelle est la différence entre ExecutorService.soumettre et ExecutorService.exécuter dans le présent code en Java?

Comme vous le voyez sur la JavaDoc execute(Runnable) ne retourne rien.

Cependant, submit(Callable<T>) renvoie une Future objet qui permet à un moyen pour vous de par programmation d'annuler le thread en cours d'exécution plus tard, ainsi que d'obtenir la T retourné lorsque la Callable complète. Voir JavaDoc de l'Avenir pour plus de détails

Future<?> future = executor.submit(longRunningJob);
...
//long running job is taking too long
future.cancel(true);

En outre,
si future.get() == null et de ne pas jeter d'exception alors Praticable exécutée avec succès

execute: L'utiliser pour le feu et oublier les appels

submit: 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

Différence majeure: Exception manipulation

submit() masque non-traitée Exception dans le cadre lui-même.

execute() jette non-traitée Exception.

Solution pour la gestion des Exceptions avec submit()

1. Envelopper votre Callable or Runnable code in try{} catch{} block

   OU

2. Garder future.get() call in try{} catch{} block

   OU

3. mettre en place votre propre ThreadPoolExecutor et remplacer afterExecute méthode

Concernant le tour d'autres questions sur la

invokeAll:

Exécute les tâches, une liste de contrats à Terme de la tenue de leur statut et de leurs résultats lors de la tous les ou à l'expiration du délai, selon la première éventualité.

invokeAny:

Exécute les tâches, en retournant le résultat de celui qui a terminé avec succès (c'est à dire, sans lever une exception), si aucun ne avant le délai est écoulé.

Utilisation invokeAll si vous voulez attendre pour toutes les tâches à effectuer.

Utilisation invokeAny si vous êtes à la recherche pour la réalisation d'une tâche de N soumis tâches. Dans ce cas, les tâches en cours sera annulée si l'une des tâches se termine avec succès.

Related post avec le code exemple:

Choisissez entre ExecutorService de soumettre et ExecutorService execute

Un principale différence entre les soumettre() et execute() la méthode est que ExecuterService.submit()peut retourner le résultat de calcul car il a un type de retour de l'Avenir, mais la méthode execute() ne retourne rien, parce que c'est le type de retour est void. Le cœur de l'interface en Java 1.5 l'Exécuteur de cadre est l'Exécuteur testamentaire de l'interface qui définit les exécuter(Runnable tâche) de la méthode, dont le principal but est de séparer la tâche de son exécution.

Toutes les tâches soumises à l'Exécuteur testamentaire peut être exécutée par le même thread, un thread de travail à partir d'un pool de threads ou de toute autre thread.

D'autre part, la méthode submit() est définie dans le ExecutorService interface qui est une sous-interface de l'Exécuteur testamentaire et ajoute les fonctionnalités de la résiliation du pool de threads, avec l'ajout de méthode submit() qui peut accepter un Callable tâche et retourne un résultat de calcul.

Similitudes entre le execute() et de le soumettre() ainsi:

1. Les deux submit() et execute() sont les méthodes utilisées pour soumettre une tâche à l'Exécuteur cadre de l'exécution asynchrone.
2. Les deux submit() et execute() peut accepter une tâche Exécutable.
3. Vous pouvez accéder à soumettre() et execute() de la ExecutorService interface, car il s'étend également à l'Exécuteur testamentaire de l'interface qui déclare la méthode execute ().

Hormis le fait que la méthode submit() peut renvoyer des résultats et execute() ne peut pas, en voici d'autres différences notables entre ces deux principales méthodes de l'Exécuteur testamentaire cadre de Java 5.

1. Le submit() peut accepter à la fois Praticable et Exigible de la tâche, mais execute() ne peut accepter que le Praticable de la tâche.
2. La méthode submit() est déclarée dans ExecutorService de l'interface, tandis que la méthode execute() est déclarée dans l'Exécuteur de l'interface.
3. Le type de retour de la méthode submit() est un objet, mais le type de retour de la méthode execute() est nulle.

essentiellement deux appels d'exécuter,si tu veux avenir de l'objet que vous appellerons méthode submit()
voici de la doc

public <T> Future<T> submit(Callable<T> task) {
if (task == null) throw new NullPointerException();
RunnableFuture<T> ftask = newTaskFor(task);
execute(ftask);
return ftask;
}
public <T> Future<T> submit(Runnable task, T result) {
if (task == null) throw new NullPointerException();
RunnableFuture<T> ftask = newTaskFor(task, result);
execute(ftask);
return ftask;
}

comme vous pouvez le voir java a vraiment aucun moyen de démarrer un thread autre que l'appel de méthode run() de l'OMI. depuis j'ai aussi trouvé que Callable.call() méthode est appelée à l'intérieur d' run() méthode. ainsi, si l'objet est remboursable, il serait toujours appeler run() méthode, qui inturn appellerais call() méthode
de doc.

public void run() {
if (state != NEW ||
!UNSAFE.compareAndSwapObject(this, runnerOffset,
null, Thread.currentThread()))
return;
try {
Callable<V> c = callable;
if (c != null && state == NEW) {
V result;
boolean ran;
try {
result = c.call();
ran = true;
} catch (Throwable ex) {
result = null;
ran = false;
setException(ex);
}
if (ran)
set(result);
}
} finally {
//runner must be non-null until state is settled to
//prevent concurrent calls to run()
runner = null;
//state must be re-read after nulling runner to prevent
//leaked interrupts
int s = state;
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
}