Méthode de soumission du pool de threads ThreadPoolExecutor

jdk1.7.0_79

Dans l'article précédent "ThreadPoolExecutor thread" Le principe du pool de threads ThreadPoolExecutor et sa méthode d'exécution sont mentionnés dans « Principe du pool et sa méthode d'exécution ». 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 son retour de 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.

　

//ExecutorServicepublic 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.

//AbstractExecutorServicepublic 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 dans de nombreux codes sources, le modèle de méthode modèle est largement utilisé. 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 de Exécution du thread, 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(Callable task) peut obtenir sa valeur de retour, 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 transmettre au thread pour traitement. La dernière méthode, submit (Runnable task), n'a pas de valeur de retour. . Même s'il obtient sa valeur de retour, elle sera nulle.

Vous trouverez ci-dessous 3 exemples pour avoir une idée de la méthode de soumission.

　soumettre (tâche appelable)

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 (exécutable tâche, 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");
    }
}

　soumettre (tâche exécutable)

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());
    }
}

À partir de l'exemple ci-dessus, vous pouvez voir que lors de l'appel de submit(Runnable runnable), son type défini n'est pas requis, bien qu'il soit défini comme méthode générique dans ExecutorService, dans AbstractExecutorService. n'est pas une méthode générique car elle n'a pas de valeur de retour. (Pour les différences entre Object, T et ?, veuillez vous référer à « La différence entre Object, T (génériques) 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 cela prend-il une tâche. un paramètre passé à newTaskFor, puis appelle la méthode d'exécution et renvoie enfin ftask ?

//AbstractExecutorService#newTaskForprotected <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 futur des threads Java - "14. Mode futur 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!