In Java , Zukunft ist ein Schnittstelle das gehört dazu java.util.concurrent Paket . Es wird verwendet, um das Ergebnis einer asynchronen Berechnung darzustellen. Die Schnittstelle stellt die Methoden bereit, um zu prüfen, ob die Berechnung abgeschlossen ist oder nicht, um auf ihren Abschluss zu warten und das Ergebnis der Berechnung abzurufen. Sobald die Aufgabe oder Berechnung abgeschlossen ist, kann die Berechnung nicht mehr abgebrochen werden.
Syntax:
public interface Future
Beispiel für Java Future
Das beste Beispiel für Java Future ist ExecutorService Schnittstelle. Es erzeugt ein Future-Objekt (aus einigen ihrer Methoden) zum Verfolgen des Fortschritts einer oder mehrerer asynchroner Aufgaben.
Methoden der zukünftigen Schnittstelle
Die Schnittstelle bietet die folgenden fünf Methoden:
| Methode | Beschreibung |
|---|---|
| stornieren() | Es wird versucht, die Ausführung der Aufgabe abzubrechen. |
| erhalten() | Die Methode wartet bei Bedarf auf den Abschluss der Berechnung und ruft dann ihr Ergebnis ab. |
| erhalten() | Wartet bei Bedarf höchstens die angegebene Zeit, bis die Berechnung abgeschlossen ist, und ruft dann das Ergebnis ab, sofern verfügbar. |
| ist storniert() | Es gibt „true“ zurück, wenn die Aufgabe vor ihrem Abschluss abgebrochen wurde. |
| erledigt() | Es gibt true zurück, wenn die Aufgabe abgeschlossen ist. |
Es gab einige Mängel der Future-Schnittstelle, die wie folgt sind:
- Bei Verwendung von Future kann die Berechnung nicht manuell durchgeführt werden.
- Es erfolgt keine Benachrichtigung, sobald die Kommutierung abgeschlossen ist.
- Seine Kette kann nicht erstellt und kombiniert werden.
Um die oben genannten Einschränkungen zu überwinden, Java 8 eingeführt Abschließbare Zukunft .
Verwendung von Future in der asynchronen Programmierung
Ergebnis erzielen
Wie wir oben besprochen haben, stellt die Zukunft das Ergebnis einer asynchronen Aufgabe dar. Um das Ergebnis dieser asynchronen Aufgabe abzurufen, stellt die Java Future-Schnittstelle die folgenden zwei Versionen der get()-Methoden bereit, die beide ein Objekt zurückgeben. Beachten Sie, dass der Rückgabetyp ein generischer Typ sein kann. Zum Beispiel:
Future future = ... // get Future by starting async task // do something else, until ready to check result via Future // get result from Future try { Object result = future.get(); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } Hinweis: Wenn wir versuchen, die Methode get() aufzurufen, bevor die asynchrone Aufgabe abgeschlossen ist, blockiert die Methode get(), bis das Ergebnis bereit ist.
Um den oben genannten Mangel zu beheben, stellt die Future-Schnittstelle eine andere Version der get()-Methode bereit, die eine Menge ausnimmt Zeit (in Millisekunden) als Parameter. Dies bedeutet, dass die Zukunft eine gewisse Zeit warten wird, um die Aufgabe abzuschließen, nachdem das Ergebnis in der Zukunft verfügbar ist. Zum Beispiel:
try { Object result = future.get(1000, TimeUnit.MILLISECONDS); } catch (InterruptedException e) { } catch (ExecutionException e) { } catch (TimeoutException e) { // thrown if timeout time interval passes // before a result is available. } Wenn Future innerhalb der angegebenen Zeit kein Ergebnis erhält, a TimeoutException wird von der Zukunft geworfen.
Brechen Sie eine asynchrone Aufgabe ab
Wir können eine asynchrone Aufgabe auch jederzeit abbrechen, indem wir die aufrufen stornieren() Methode der Future-Schnittstelle. Zum Beispiel:
Future future = ... // Get Future from somewhere future.cancel();
Überprüfen Sie, ob eine asynchrone Aufgabe erledigt ist
Die Schnittstelle stellt eine Methode bereit erledigt() um zu überprüfen, ob die asynchrone Aufgabe abgeschlossen ist oder nicht. Zum Beispiel:
Future future = ... // Get Future from somewhere if(future.isDone()) { Object result = future.get(); } else { // do something else } Überprüfen Sie, ob eine asynchrone Aufgabe abgebrochen wurde
Die Future-Schnittstelle stellt eine Methode bereit ist storniert() um zu prüfen, ob die durch Future dargestellte asynchrone Aufgabe abgebrochen wird oder nicht. Es gibt „true“ zurück, wenn die Aufgabe erfolgreich abgebrochen wurde, andernfalls wird „false“ zurückgegeben. Zum Beispiel:
Future future = ... // get Future from somewhere if(future.isCancelled()) { } else { } Beispiel für Java Future
FutureExample.java
import java.util.concurrent.*; public class FutureExample { public static void main(String args[]) throws InterruptedException, ExecutionException { //ExecutorService allows us to execute tasks on threads asynchronously ExecutorService es = Executors.newSingleThreadExecutor(); //getting future //the method submit() submits a value-returning task for execution and returns the Future Future future = es.submit(() -> { //sleep thread for 2 seconds Thread.sleep(2000); return 'Welcome to Javatpoint'; }); //checks if the task is completed or not while(!future.isDone()) { System.out.println('The task is still in process.....'); //sleep thread for 2 milliseconds Thread.sleep(200); } System.out.println('Task completed! getting the result'); //getting the result after completing the task String result = future.get(); //prints the result System.out.println(result); es.shutdown(); } } Ausgabe:
