Ban ben Jáva , Jövő egy felület ami hozzá tartozik java.util.concurrent csomag . Egy aszinkron számítás eredményének ábrázolására szolgál. Az interfész lehetőséget ad annak ellenőrzésére, hogy a számítás befejeződött-e vagy sem, hogy megvárjuk a befejezést, és lekérjük a számítás eredményét. A feladat vagy a számítás befejezése után a számítást nem lehet megszakítani.
Szintaxis:
public interface Future
Példa a Java Future-ra
A Java Future legjobb példája az VégrehajtóSzolgálat felület. Előállít egy Future objektumot (egyes módszereikből) egy vagy több aszinkron feladat előrehaladásának nyomon követésére.
A jövő interfész módszerei
Az interfész a következő öt módszert kínálja:
| Módszer | Leírás |
|---|---|
| megszünteti() | Megpróbálja megszakítani a feladat végrehajtását. |
| kap() | A metódus szükség esetén megvárja a számítás befejezését, majd lekéri az eredményt. |
| kap() | Ha szükséges, legfeljebb a megadott ideig vár a számítás befejeződéséig, majd lekéri az eredményt, ha elérhető. |
| törölve() | Igaz értéket ad vissza, ha a feladatot a befejezése előtt törölték. |
| kész() | Igazat ad vissza, ha a feladat befejeződött. |
A Future felületnek volt néhány hiányossága, amelyek a következők:
- A Future használatával a számítás nem fejezhető be manuálisan.
- Nem értesít, ha a kommutáció befejeződött.
- Lánca nem hozható létre és nem kombinálható.
A fenti korlátok leküzdése érdekében Java 8 bemutatott CompletableFuture .
A jövő használata az aszinkron programozásban
Eredmény elérése
Ahogy fentebb tárgyaltuk, a Jövő egy aszinkron feladat eredménye. Az aszinkron feladat eredményének lekéréséhez a Java Future felület a get() metódusok következő két változatát biztosítja, amelyek egy objektumot adnak vissza. Vegye figyelembe, hogy a visszatérési típus általános típus lehet. Például:
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(); } Megjegyzés: Ha megpróbáljuk meghívni a get() metódust az aszinkron feladat befejezése előtt, a get() metódus blokkolni fog, amíg az eredmény készen nem lesz.
A fenti hiányosság kiküszöbölése érdekében a Future felület a get() metódus egy másik változatát biztosítja, amely kivételt képez idő (ezredmásodpercben) paraméterként. Ez azt jelenti, hogy a Jövő bizonyos ideig vár a feladat elvégzésére, miután az eredmény elérhető lesz a Jövőben. Például:
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. } Ha a Future nem ad eredményt a megadott időn belül, a TimeoutException dobja a Jövő.
Töröljön egy aszinkron feladatot
Az aszinkron feladatot bármikor törölhetjük, ha meghívjuk a megszünteti() a Future interfész módszere. Például:
Future future = ... // Get Future from somewhere future.cancel();
Ellenőrizze, hogy az aszinkron feladat elkészült-e
Az interfész módszert ad kész() annak ellenőrzésére, hogy az aszinkron feladat befejeződött-e vagy sem. Például:
Future future = ... // Get Future from somewhere if(future.isDone()) { Object result = future.get(); } else { // do something else } Ellenőrizze, hogy egy aszinkron feladat megszakadt-e
A Future felület egy módszert biztosít törölve() annak ellenőrzésére, hogy a Future által képviselt aszinkron feladat törölve van-e vagy sem. Igazat ad vissza, ha a feladatot sikeresen törölték, egyébként hamis értéket ad vissza. Például:
Future future = ... // get Future from somewhere if(future.isCancelled()) { } else { } Példa a Java Future-ra
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(); } } Kimenet:
