Detaillierte Erläuterung der Submit-Methode des ThreadPoolExecutor-Thread-Pools in JAVA

Der folgende Editor wird Ihnen einen kurzen Vortrag über die Submit-Methode des ThreadPoolExecutor-Thread-Pools geben. Der Herausgeber findet es ziemlich gut, deshalb teile ich es jetzt mit Ihnen und gebe es als Referenz. Kommen Sie und werfen Sie einen Blick mit dem Editor

jdk1.7.0_79

Im vorherigen Artikel „ThreadPoolExecutor-Thread-Pool-Prinzip und seine Ausführungsmethode“ wurden das Prinzip des Thread-Pools ThreadPoolExecutor und seine Ausführungsmethode erwähnt. Dieser Artikel analysiert ThreadPoolExecutor#submit.

Für die Ausführung einer Aufgabe ist es manchmal nicht erforderlich, dass sie Ergebnisse zurückgibt, aber wir benötigen die Rückgabe von Ausführungsergebnissen. Wenn ein Thread kein Ergebnis zurückgeben muss, kann er Runnable implementieren, und wenn er das Ergebnis ausführen muss, kann er Callable implementieren. Im Thread-Pool stellt Execute auch eine Aufgabenausführung bereit, die keine Ergebnisse zurückgeben muss, und für diejenigen, die Ergebnisse zurückgeben müssen, kann die Submit-Methode aufgerufen werden.

Überprüfen Sie die Vererbungsbeziehung von ThreadPoolExecutor.

Nur ​​die Ausführungsmethode ist in der Executor-Schnittstelle definiert, während die Submit-Methode in der ExecutorService-Schnittstelle definiert ist.

//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);
　　...
}

Die Submit-Methode ist in ihrer Unterklasse AbstractExecutorService implementiert.

//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; 
　　}
　　...
}

Die in AbstractExecutorService implementierte Submit-Methode ist eigentlich eine Vorlagenmethode, die das Algorithmusgerüst der Submit-Methode definiert und deren Ausführung an die Unterklasse übergeben wird. (Es ist ersichtlich, dass das Vorlagenmethodenmuster in vielen Quellcodes weit verbreitet ist. Informationen zum Vorlagenmethodenmuster finden Sie unter „Vorlagenmethodenmuster“)

Obwohl die Submit-Methode den Rückgabewert eines Threads bereitstellen kann Bei der Ausführung wird nur Callable implementiert. Es gibt einen Rückgabewert, aber der Thread, der Runnable implementiert, hat keinen Rückgabewert. Das heißt, unter den oben genannten drei Methoden kann subscribe(Callable task) seinen Rückgabewert erhalten Submit (Ausführbare Aufgabe, T-Ergebnis) kann den Rückgabewert des Threads indirekt über das eingehende Trägerergebnis abrufen oder, um genau zu sein, zur Verarbeitung an den Thread übergeben. Die letzte Methode, Submit (Ausführbare Aufgabe), hat keine Rückgabe Auch wenn es seinen Rückgabewert erhält, ist es null .

Hier sind drei Beispiele, um ein Gefühl für die Absendemethode zu bekommen.

submit(Callable task)

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

submit(Runnable task, T result)

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

Anhand des obigen Beispiels können Sie sehen, dass der definierte Typ beim Aufruf vonsubmit(Runnable runnable) nicht erforderlich ist, was bedeutet, dass obwohl Es ist eine generische Methode, die in ExecutorService definiert ist, aber keine generische Methode in AbstractExecutorService, da sie keinen Rückgabewert hat. (Informationen zu den Unterschieden zwischen Object, T und ? finden Sie unter „Unterschiede zwischen Object, T (generisch) und ? in Java “).

Wie Sie dem Quellcode oben entnehmen können, sind diese drei Methoden fast gleich. Der Schlüssel liegt darin:

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

Wie eine Aufgabe als Parameter an newTaskFor übergeben wird, und Wie wäre es dann mit dem Aufruf der Methode „execute“ und der abschließenden Rückgabe von „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);
}

Es scheint, dass eine FutureTask-Instanz zurückgegeben wird und FutureTask die Future- und Runnable-Schnittstellen implementiert. Die Future-Schnittstelle ist eine Implementierung des Java-Thread-Future-Modus, der für asynchrone Berechnungen verwendet werden kann. Die Implementierung der Runnable-Schnittstelle bedeutet, dass sie als Thread ausgeführt werden kann. FutureTask implementiert diese beiden Schnittstellen, was bedeutet, dass es das Ergebnis einer asynchronen Berechnung darstellt und als Thread zur Ausführung an den Executor übergeben werden kann. FutureTask wird im nächsten Kapitel separat analysiert. Daher ist die Analyse der Submit-Methode des Thread-Pools ThreadPoolExecutor in diesem Artikel nicht vollständig. Sie müssen den Future-Modus von Java-Threads verstehen – „Ein Klischee über den Future-Modus in Java“.

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der Submit-Methode des ThreadPoolExecutor-Thread-Pools in JAVA. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!