I Java , Fremtid er en interface der hører til java.util.samtidig pakke . Det bruges til at repræsentere resultatet af en asynkron beregning. Grænsefladen giver metoderne til at kontrollere, om beregningen er fuldført eller ej, til at vente på dens færdiggørelse og til at hente resultatet af beregningen. Når først opgaven eller beregningen er fuldført, kan man ikke annullere beregningen.
Syntaks:
public interface Future
Eksempel på Java Future
Det bedste eksempel på Java Future er ExecutorService interface. Det producerer et Future (fra nogle af deres metoder) objekt til at spore fremskridt for en eller flere asynkrone opgaver.
Fremtidens grænseflade
Grænsefladen giver følgende fem metoder:
| Metode | Beskrivelse |
|---|---|
| afbestille() | Den forsøger at annullere udførelsen af opgaven. |
| få() | Metoden venter om nødvendigt på, at beregningen er fuldført, og henter derefter resultatet. |
| få() | Venter om nødvendigt i højst det givne tidspunkt, før beregningen er fuldført, og henter derefter resultatet, hvis det er tilgængeligt. |
| er annulleret() | Det returnerer sandt, hvis opgaven blev annulleret før den blev fuldført. |
| Er gjort() | Det returnerer sandt, hvis opgaven er fuldført. |
Der var nogle mangler ved Future-grænsefladen, som er som følger:
- Ved at bruge Future kan beregningen ikke udføres manuelt.
- Den giver ikke besked, når kommuteringen er afsluttet.
- Dens kæde kan ikke skabes og kombineres.
For at overvinde ovenstående begrænsninger, Java 8 introduceret CompletableFuture .
Brug af Future i asynkron programmering
Får resultat
Som vi har diskuteret ovenfor, repræsenterer Fremtiden resultatet af en asynkron opgave. For at hente resultatet af den asynkrone opgave giver Java Future-grænsefladen følgende to versioner af get()-metoderne, der begge returnerer et objekt. Bemærk, at returtypen kan være en generisk type. For eksempel:
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(); } Bemærk: Hvis vi forsøger at påkalde get()-metoden, før den asynkrone opgave er fuldført, vil get()-metoden blokere, indtil resultatet er klar.
For at overvinde ovenstående mangel, giver Future-grænsefladen en anden version af get()-metoden, der undtager en mængde af tid (i millisekunder) som en parameter. Det repræsenterer, at fremtiden vil vente et stykke tid på at fuldføre opgaven, efter at resultatet vil være tilgængeligt i fremtiden. For eksempel:
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. } Hvis Future ikke får noget resultat inden for den angivne tid, a Timeout Undtagelse er kastet af Fremtiden.
Annuller en asynkron opgave
Vi kan også annullere en asynkron opgave på et hvilket som helst tidspunkt ved at ringe til afbestille() Fremtidens grænseflades metode. For eksempel:
Future future = ... // Get Future from somewhere future.cancel();
Tjek, om en asynkron opgave er udført
Grænsefladen giver en metode Er gjort() for at kontrollere, om den asynkrone opgave er fuldført eller ej. For eksempel:
Future future = ... // Get Future from somewhere if(future.isDone()) { Object result = future.get(); } else { // do something else } Tjek, om en asynkron opgave er annulleret
Fremtidens grænseflade giver en metode er annulleret() for at kontrollere, om den asynkrone opgave repræsenteret af Future er annulleret eller ej. Det returnerer sandt, hvis opgaven annulleres med succes, ellers returnerer den falsk. For eksempel:
Future future = ... // get Future from somewhere if(future.isCancelled()) { } else { } Eksempel 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:
