Der Inhalt dieses Artikels ist eine detaillierte Einführung (Codebeispiel) über Callable und Future in Java. Ich hoffe, dass er für Sie hilfreich ist.
Der Grund, warum Callable und Future angezeigt werden
Es gibt zwei Möglichkeiten, einen Thread zu erstellen: Eine besteht darin, Thread direkt zu erben, und die andere darin, die Runnable-Schnittstelle zu implementieren .
Beide Methoden weisen einen Fehler auf: Die Ausführungsergebnisse können nicht abgerufen werden, nachdem die Aufgabe ausgeführt wurde.
Wenn Sie die Ausführungsergebnisse erhalten müssen, müssen Sie den Effekt durch gemeinsam genutzte Variablen oder Thread-Kommunikation erzielen, was schwieriger zu verwenden ist.
Seit Java 1.5 werden Callable und Future bereitgestellt, über die die Ergebnisse der Aufgabenausführung nach Abschluss der Aufgabenausführung abgerufen werden können.
Einführung in Callable und Future
Die Callable-Schnittstelle stellt einen Codeabschnitt dar, der aufgerufen werden kann und Ergebnisse zurückgibt; die Future-Schnittstelle stellt eine asynchrone Aufgabe dar, nämlich die Zukunft gegeben durch das noch nicht erledigte Ergebnis. Callable wird also verwendet, um Ergebnisse zu generieren, und Future wird verwendet, um Ergebnisse zu erhalten.
Die Callable-Schnittstelle verwendet Generika, um ihren Rückgabetyp zu definieren. Die Executors-Klasse bietet einige nützliche Methoden zum Ausführen von Aufgaben innerhalb des Callable im Thread-Pool. Da die aufrufbare Aufgabe parallel ist (parallel bedeutet, dass das Ganze parallel aussieht, tatsächlich nur ein Thread zu einem bestimmten Zeitpunkt ausgeführt wird), müssen wir auf das Ergebnis warten, das sie zurückgibt.
Das java.util.concurrent.Future-Objekt löst dieses Problem für uns. Nachdem der Thread-Pool die Callable-Aufgabe übermittelt hat, wird ein Future-Objekt zurückgegeben. Sie können es verwenden, um den Status der Callable-Aufgabe zu ermitteln und das von der Callable-Aufgabe zurückgegebene Ausführungsergebnis abzurufen. Future stellt die Methode get() bereit, damit wir auf das Ende des Callable warten und dessen Ausführungsergebnisse erhalten können.
Callable and Runnable
java.lang.Runnable, es ist eine Schnittstelle und nur eine run()-Methode ist darin deklariert:
public interface Runnable {
public abstract void run();
}Da der Rückgabewert der run()-Methode vom Typ void ist, können nach Ausführung der Aufgabe keine Ergebnisse zurückgegeben werden.
Callable befindet sich unter dem Paket java.util.concurrent. Es ist auch eine Schnittstelle darin, aber diese Methode heißt call():
public interface Callable<V> {
/**
* Computes a result, or throws an exception if unable to do so.
*
* @return computed result
* @throws Exception if unable to compute a result
*/
V call() throws Exception;
}This ist ein Bei generischen Schnittstellen ist der von der Funktion call() zurückgegebene Typ der übergebene V-Typ.
Im Allgemeinen wird es in Verbindung mit ExecutorService verwendet. In der ExecutorService-Schnittstelle werden mehrere überladene Versionen der Submit-Methode deklariert.
<T> Future<T> submit(Callable<T> task); <T> Future<T> submit(Runnable task, T result); Future<?> submit(Runnable task);
Der Parametertyp in der ersten Submit-Methode ist Callable.
Vorerst müssen Sie nur wissen, dass Callable im Allgemeinen in Verbindung mit ExecutorService verwendet wird. Die spezifische Verwendungsmethode wird später beschrieben.
Im Allgemeinen verwenden wir die erste Übermittlungsmethode und die dritte Übermittlungsmethode, und die zweite Übermittlungsmethode wird selten verwendet.
Zukunft besteht darin, das Ausführungsergebnis einer bestimmten ausführbaren oder aufrufbaren Aufgabe abzubrechen, abzufragen, ob sie abgeschlossen ist, und das Ergebnis abzurufen. Bei Bedarf können Sie das Ausführungsergebnis über die get-Methode abrufen, die blockiert, bis die Aufgabe das Ergebnis zurückgibt.
Die Future-Klasse befindet sich unter dem Paket java.util.concurrent. Es handelt sich um eine Schnittstelle:
public interface Future<V> {
boolean cancel(boolean mayInterruptIfRunning);
boolean isCancelled();
boolean isDone();
V get() throws InterruptedException, ExecutionException;
V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}public interface RunnableFuture<V> extends Runnable, Future<V> {
void run();
}public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
sync = new Sync(callable);
}
public FutureTask(Runnable runnable, V result) {
sync = new Sync(Executors.callable(runnable, result));
}如上提供了两个构造函数，一个以Callable为参数，另外一个以Runnable为参数。这些类之间的关联对于任务建模的办法非常灵活，允许你基于FutureTask的Runnable特性（因为它实现了Runnable接口），把任务写成Callable，然后封装进一个由执行者调度并在必要时可以取消的FutureTask。
FutureTask可以由执行者调度，这一点很关键。它对外提供的方法基本上就是Future和Runnable接口的组合：get()、cancel、isDone()、isCancelled()和run()，而run()方法通常都是由执行者调用，我们基本上不需要直接调用它。
public class MyCallable implements Callable<String> {
private long waitTime;
public MyCallable(int timeInMillis){
this.waitTime=timeInMillis;
}
@Override
public String call() throws Exception {
Thread.sleep(waitTime);
//return the thread name executing this callable task
return Thread.currentThread().getName();
}
}public class FutureTaskExample {
public static void main(String[] args) {
MyCallable callable1 = new MyCallable(1000); // 要执行的任务
MyCallable callable2 = new MyCallable(2000);
FutureTask<String> futureTask1 = new FutureTask<String>(callable1);// 将Callable写的任务封装到一个由执行者调度的FutureTask对象
FutureTask<String> futureTask2 = new FutureTask<String>(callable2);
ExecutorService executor = Executors.newFixedThreadPool(2); // 创建线程池并返回ExecutorService实例
executor.execute(futureTask1); // 执行任务
executor.execute(futureTask2);
while (true) {
try {
if(futureTask1.isDone() && futureTask2.isDone()){// 两个任务都完成
System.out.println("Done");
executor.shutdown(); // 关闭线程池和服务
return;
}
if(!futureTask1.isDone()){ // 任务1没有完成，会等待，直到任务完成
System.out.println("FutureTask1 output="+futureTask1.get());
}
System.out.println("Waiting for FutureTask2 to complete");
String s = futureTask2.get(200L, TimeUnit.MILLISECONDS);
if(s !=null){
System.out.println("FutureTask2 output="+s);
}
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}catch(TimeoutException e){
//do nothing
}
}
}
}Das obige ist der detaillierte Inhalt vonDetaillierte Einführung in Callable und Future im Java-Multithreading (Codebeispiel). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
