In Java , Toekomst is een koppel dat hoort bij java.util.concurrent pakket . Het wordt gebruikt om het resultaat van een asynchrone berekening weer te geven. De interface biedt de methoden om te controleren of de berekening al dan niet is voltooid, om te wachten tot deze is voltooid en om het resultaat van de berekening op te halen. Zodra de taak of berekening is voltooid, kan de berekening niet meer worden geannuleerd.
Syntaxis:
public interface Future
Voorbeeld van Java-toekomst
Het beste voorbeeld van Java Future is ExecuteurService koppel. Het produceert een Future-object (van sommige van hun methoden) voor het volgen van de voortgang van een of meer asynchrone taken.
Methoden van de toekomstige interface
De interface biedt de volgende vijf methoden:
| Methode | Beschrijving |
|---|---|
| annuleren() | Er wordt geprobeerd de uitvoering van de taak te annuleren. |
| krijgen() | De methode wacht indien nodig tot de berekening is voltooid en haalt vervolgens het resultaat op. |
| krijgen() | Wacht indien nodig maximaal de opgegeven tijd totdat de berekening is voltooid en haalt vervolgens het resultaat op, indien beschikbaar. |
| gaat niet door() | Het retourneert True als de taak is geannuleerd voordat deze is voltooid. |
| is klaar() | Het retourneert true als de taak is voltooid. |
Er was een aantal tekortkomingen in de Future-interface, namelijk:
- Met Future kan de berekening niet handmatig worden voltooid.
- Er wordt geen melding gemaakt zodra de afkoop is voltooid.
- De keten ervan kan niet worden gecreëerd en gecombineerd.
Om de bovengenoemde beperkingen te overwinnen, Java 8 geïntroduceerd Voltooibare toekomst .
Future gebruiken bij asynchrone programmering
Resultaat behalen
Zoals we hierboven hebben besproken, vertegenwoordigt de Toekomst het resultaat van een asynchrone taak. Om het resultaat van die asynchrone taak op te halen, biedt de Java Future-interface de volgende twee versies van de get()-methoden die beide een object retourneren. Houd er rekening mee dat het retourtype een generiek type kan zijn. Bijvoorbeeld:
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(); } Opmerking: als we de methode get() proberen aan te roepen voordat de asynchrone taak is voltooid, wordt de methode get() geblokkeerd totdat het resultaat gereed is.
Om de bovenstaande tekortkoming te ondervangen, biedt de Future-interface een andere versie van de get()-methode die een hoeveelheid van tijd (in milliseconden) als parameter. Het geeft aan dat de Toekomst een bepaalde tijd zal wachten om de taak te voltooien, nadat het resultaat beschikbaar zal zijn in de Toekomst. Bijvoorbeeld:
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. } Als Future binnen de gestelde tijd geen resultaat krijgt, a Time-outuitzondering wordt gegooid door de Toekomst.
Annuleer een asynchrone taak
We kunnen ook op elk moment een asynchrone taak annuleren door de annuleren() methode van de Future-interface. Bijvoorbeeld:
Future future = ... // Get Future from somewhere future.cancel();
Controleer of een asynchrone taak is voltooid
De interface biedt een methode is klaar() om te controleren of de asynchrone taak is voltooid of niet. Bijvoorbeeld:
Future future = ... // Get Future from somewhere if(future.isDone()) { Object result = future.get(); } else { // do something else } Controleer of een asynchrone taak is geannuleerd
De Future-interface biedt een methode gaat niet door() om te controleren of de asynchrone taak die door Future wordt vertegenwoordigd, is geannuleerd of niet. Het retourneert waar als de taak met succes is geannuleerd, anders wordt onwaar geretourneerd. Bijvoorbeeld:
Future future = ... // get Future from somewhere if(future.isCancelled()) { } else { } Voorbeeld van Java-toekomst
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(); } } Uitgang:
