Explication détaillée de la méthode de soumission du pool de threads ThreadPoolExecutor en JAVA

L'éditeur suivant vous présentera une brève présentation de la méthode de soumission du pool de threads ThreadPoolExecutor. L'éditeur le trouve plutôt bon, je vais donc le partager avec vous maintenant et le donner comme référence pour tout le monde. Venez jeter un oeil avec l'éditeur

jdk1.7.0_79

Dans l'article précédent "Principe du pool de threads ThreadPoolExecutor et sa méthode d'exécution", le principe du pool de threads ThreadPoolExecutor et sa méthode d'exécution ont été évoqués. Cet article analyse ThreadPoolExecutor#submit.

Pour l'exécution d'une tâche, parfois nous n'en avons pas besoin pour renvoyer des résultats, mais il y a des moments où nous avons besoin de ses résultats d'exécution. Pour un thread, s'il n'a pas besoin de renvoyer un résultat, il peut implémenter Runnable, et s'il a besoin d'exécuter le résultat, il peut implémenter Callable. Dans le pool de threads, execute fournit également une exécution de tâche qui n'a pas besoin de renvoyer de résultats, et pour celles qui doivent renvoyer des résultats, sa méthode submit peut être appelée.

Examinez la relation d'héritage de ThreadPoolExecutor.

Seule la méthode d'exécution est définie dans l'interface Executor, tandis que la méthode submit est définie dans l'interface ExecutorService.

//ExecutorService
public interface ExecutorService extends Executor {
　　...
　　<T> Future<T> submit(Callable<T> task);
　　<T> Future<T> submit(Runnable task, T result);
　　<T> Future<T> submit(Runnable task);
　　...
}

La méthode submit est implémentée dans sa sous-classe AbstractExecutorService.

//AbstractExecutorService
public abstract class AbstractExecutorService implements ExecutorService {
　　...
　　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);
　　　　execute(ftask);
　　　　return ftask;
　　}
　　public Future<?> submit(Runnable task) {
　　　　if (task == null) throw new NullPointerExeption();
　　　　RunnableFuture<Void> ftask = newTaskFor(task, null);
　　　　execute(ftask);
　　　　return ftask; 
　　}
　　...
}

La méthode submit implémentée dans AbstractExecutorService est en fait une méthode modèle qui définit le squelette de l'algorithme de la méthode submit, et son exécution est confiée à la sous-classe. (On peut voir que le modèle de méthode modèle est largement utilisé dans de nombreux codes sources. Pour le modèle de méthode modèle, veuillez vous référer à "Modèle de méthode modèle")

Bien que la méthode submit puisse fournir la valeur de retour du fil exécution, seul Callable est implémenté Il y aura une valeur de retour, mais le thread qui implémente Runnable n'a pas de valeur de retour, c'est-à-dire que parmi les trois méthodes ci-dessus, submit(Callable8742468051c85b06f0a0af9e3e506b5c task) peut obtenir sa valeur de retour, et submit(Runnable task, T result) peut obtenir indirectement la valeur de retour du thread via le résultat du transporteur entrant ou, pour être précis, la remettre au thread pour traitement. La dernière méthode, submit (Runnable task), n'a aucun retour. value Même s’il obtient sa valeur de retour, elle sera null .

Voici trois exemples pour avoir une idée de la méthode de soumission.

soumettre (tâche exécutable8742468051c85b06f0a0af9e3e506b5c)

package com.threadpoolexecutor;

import java.util.concurrent.*;

/**
 * ThreadPoolExecutor#sumit(Callable<T> task)
 * Created by yulinfeng on 6/17/17.
 */
public class Sumit1 {

 public static void main(String[] args) throws ExecutionException, InterruptedException {
 Callable<String> callable = new Callable<String>() {
 public String call() throws Exception {
 System.out.println("This is ThreadPoolExetor#submit(Callable<T> task) method.");
 return "result";
 }
 };

 ExecutorService executor = Executors.newSingleThreadExecutor();
 Future<String> future = executor.submit(callable);
 System.out.println(future.get());
 }
}

soumettre (tâche exécutable, résultat T)

package com.threadpoolexecutor;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * ThreadPoolExecutor#submit(Runnable task, T result)
 * Created by yulinfeng on 6/17/17.
 */
public class Submit2 {

 public static void main(String[] args) throws ExecutionException, InterruptedException {

 ExecutorService executor = Executors.newSingleThreadExecutor();
 Data data = new Data();
 Future<Data> future = executor.submit(new Task(data), data);
 System.out.println(future.get().getName());
 }
}

class Data {
 String name;

 public String getName() {
 return name;
 }

 public void setName(String name) {
 this.name = name;
 }
}

class Task implements Runnable {
 Data data;

 public Task(Data data) {
 this.data = data;
 }
 public void run() {
 System.out.println("This is ThreadPoolExetor#submit(Runnable task, T result) method.");
 data.setName("kevin");
 }
}

submit(Runnable task)

package com.threadpoolexecutor;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * ThreadPoolExecutor#sumit(Runnable runnables)
 * Created by yulinfeng on 6/17/17.
 */
public class Submit {

 public static void main(String[] args) throws ExecutionException, InterruptedException {
 Runnable runnable = new Runnable() {
 public void run() {
 System.out.println("This is ThreadPoolExetor#submit(Runnable runnable) method.");
 }
 };

 ExecutorService executor = Executors.newSingleThreadExecutor();
 Future future = executor.submit(runnable);
 System.out.println(future.get());
 }
}

Grâce à l'exemple ci-dessus, vous pouvez voir que son type défini n'est pas requis lors de l'appel de submit(Runnable runnable), ce qui signifie que bien qu'il est définie comme une méthode générique dans ExecutorService, mais ce n'est pas une méthode générique dans AbstractExecutorService car elle n'a pas de valeur de retour. (Pour les différences entre Objet, T et ?, veuillez vous référer à "Différences entre Objet, T (générique) et ? en Java ").

Comme vous pouvez le voir dans le code source ci-dessus, ces trois méthodes sont presque les mêmes. La clé réside dans :

RunnableFuture<T> ftask = newTaskFor(task);
execute(ftask);

Comment il passe une tâche en tant que paramètre à newTaskFor, et alors qu'en est-il d'appeler la méthode d'exécution et de renvoyer enfin ftask ?

//AbstractExecutorService#newTaskFor
protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
　　return new FutureTask<T>(callable);
}
　　protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
　　return new FutureTask<T>(runnable, value);
}

Il semble qu'une instance FutureTask soit renvoyée et FutureTask implémente les interfaces Future et Runnable. L'interface Future est une implémentation du mode Future du thread Java, qui peut être utilisé pour des calculs asynchrones. L'implémentation de l'interface Runnable signifie qu'elle peut être exécutée en tant que thread. FutureTask implémente ces deux interfaces, ce qui signifie qu'elle représente le résultat d'un calcul asynchrone et peut être transmise à l'Executor en tant que thread pour l'exécution. FutureTask sera analysé séparément dans le chapitre suivant. Par conséquent, l'analyse de cet article de la méthode de soumission du pool de threads ThreadPoolExecutor n'est pas complète. Vous devez comprendre le mode Future des threads Java - "Un cliché sur le mode Future en Java".

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!