Detaillierte Einführung in Callable und Future im Java-Multithreading (Codebeispiel)

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.

Verwendung von Callable

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

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

deklariert 5 Methoden in der Future-Schnittstelle. Die Funktion jeder Methode wird unten erläutert >

• Die Abbruchmethode wird zum Abbrechen der Aufgabe verwendet. Wenn der Aufgabenabbruch erfolgreich ist, wird „true“ zurückgegeben. Wenn der Aufgabenabbruch fehlschlägt, wird „false“ zurückgegeben. Der Parameter mayInterruptIfRunning gibt an, ob ausgeführte, aber noch nicht abgeschlossene Aufgaben abgebrochen werden dürfen. Wenn er auf true gesetzt ist, bedeutet dies, dass laufende Aufgaben abgebrochen werden können. Wenn die Aufgabe abgeschlossen wurde, unabhängig davon, ob mayInterruptIfRunning wahr oder falsch ist, gibt diese Methode definitiv false zurück. Das heißt, wenn die abgeschlossene Aufgabe abgebrochen wird, gibt sie false zurück, wenn die Aufgabe ausgeführt wird, wenn mayInterruptIfRunning auf true gesetzt ist. Es wird „true“ zurückgegeben. Wenn „mayInterruptIfRunning“ auf „false“ gesetzt ist, wird „false“ zurückgegeben. Wenn die Aufgabe nicht ausgeführt wurde, wird „mayInterruptIfRunning“ auf jeden Fall „true“ zurückgegeben.

• Die Methode isCancelled gibt an, ob die Aufgabe erfolgreich abgebrochen wurde, bevor die Aufgabe normal abgeschlossen wurde.

• isDone-Methode gibt an, ob die Aufgabe abgeschlossen wurde. Wenn die Aufgabe abgeschlossen ist, wird true zurückgegeben.

• get()-Methode wird verwendet um das Ausführungsergebnis zu erhalten, wird es verwendet, um das Ausführungsergebnis zu erhalten Es wurde nicht innerhalb der angegebenen Zeit abgerufen. Wenn das Ergebnis erreicht ist, wird direkt null zurückgegeben.

• Future bietet drei Funktionen:

um festzustellen, ob die Aufgabe abgeschlossen ist; in der Lage sein, die Aufgabe zu unterbrechen;

1. kann die Ergebnisse der Aufgabenausführung erhalten.
   Da Future nur eine Schnittstelle ist, kann es nicht direkt zum Erstellen von Objekten verwendet werden. Daher gibt es die folgende FutureTask.
2. FutureTask
   FutureTask implementiert die RunnableFuture-Schnittstelle wie folgt:

3. public interface RunnableFuture<V> extends Runnable, Future<V> {  
       void run();  
   }

   Sie können sehen, dass diese Schnittstelle das Runnable implementiert und Future-Schnittstellen. Die spezifische Implementierung in der Schnittstelle wird von FutureTask implementiert. Die beiden Konstruktionsmethoden dieser Klasse lauten wie folgt:

   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()方法通常都是由执行者调用，我们基本上不需要直接调用它。

   FutureTask的例子

   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!