I Java , Framtida är en gränssnitt som hör till java.util.samtidig paket . Den används för att representera resultatet av en asynkron beräkning. Gränssnittet tillhandahåller metoder för att kontrollera om beräkningen är klar eller inte, för att vänta på att den är klar och för att hämta resultatet av beräkningen. När uppgiften eller beräkningen är klar kan man inte avbryta beräkningen.
Syntax:
public interface Future
Exempel på Java Future
Det bästa exemplet på Java Future är ExecutorService gränssnitt. Den producerar ett Future-objekt (från några av deras metoder) för att spåra framsteg för en eller flera asynkrona uppgifter.
Metoder för framtidens gränssnitt
Gränssnittet tillhandahåller följande fem metoder:
| Metod | Beskrivning |
|---|---|
| Avbryt() | Den försöker avbryta utförandet av uppgiften. |
| skaffa sig() | Metoden väntar vid behov på att beräkningen ska slutföras och hämtar sedan sitt resultat. |
| skaffa sig() | Väntar vid behov, högst den givna tiden för att beräkningen ska slutföras, och hämtar sedan resultatet, om tillgängligt. |
| isCancelled() | Den returnerar sant om uppgiften avbröts innan den slutfördes. |
| är klart() | Den returnerar sant om uppgiften är klar. |
Det fanns några brister i Future-gränssnittet som är följande:
- Med Future kan beräkningen inte slutföras manuellt.
- Den meddelar inte när kommuteringen är klar.
- Dess kedja kan inte skapas och kombineras.
För att övervinna ovanstående begränsningar, Java 8 infördes CompletableFuture .
Använda Future i asynkron programmering
Får resultat
Som vi har diskuterat ovan representerar Framtiden resultatet av en asynkron uppgift. För att hämta resultatet av den asynkrona uppgiften tillhandahåller Java Future-gränssnittet följande två versioner av get()-metoderna som båda returnerar ett objekt. Observera att returtypen kan vara en generisk typ. Till exempel:
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(); } Obs: Om vi försöker anropa metoden get() innan den asynkrona uppgiften är klar, kommer metoden get() att blockeras tills resultatet är klart.
För att övervinna ovanstående brist tillhandahåller Future-gränssnittet en annan version av get()-metoden som förutom en mängd tid (i millisekunder) som en parameter. Det representerar att Framtiden kommer att vänta en tid för att slutföra uppgiften efter att resultatet kommer att vara tillgängligt i Framtiden. Till exempel:
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. } Om Future inte får något resultat inom den angivna tiden, a TimeoutException kastas av framtiden.
Avbryt en asynkron uppgift
Vi kan också avbryta en asynkron uppgift när som helst genom att anropa Avbryt() metod för Future-gränssnittet. Till exempel:
Future future = ... // Get Future from somewhere future.cancel();
Kontrollera om en asynkron uppgift är klar
Gränssnittet tillhandahåller en metod är klart() för att kontrollera om den asynkrona uppgiften är klar eller inte. Till exempel:
Future future = ... // Get Future from somewhere if(future.isDone()) { Object result = future.get(); } else { // do something else } Kontrollera om en asynkron uppgift är avbruten
Future-gränssnittet tillhandahåller en metod isCancelled() för att kontrollera om den asynkrona uppgiften som representeras av Future är avbruten eller inte. Den returnerar sant om uppgiften avbryts framgångsrikt, annars returneras falskt. Till exempel:
Future future = ... // get Future from somewhere if(future.isCancelled()) { } else { } Exempel på 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(); } } Produktion:
