CKTIS / Java
Future.get: pridobivanje rezultata opravila ali obravnava napake
Pridobi rezultat asinhronega opravila in loči njegov neuspeh od prekinitve, preklica, poteka časovne omejitve čakanja ali napake pri samem klicu `invokeAll`.
Različica: Java SE 21
Sintaksa
java.util.concurrent.Future<V>
V get() throws InterruptedException, ExecutionException
V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutExceptionFuture.get pridobi rezultat asinhronega izračuna, ki ga predstavlja objekt java.util.concurrent.Future<V>. get() brez argumentov po potrebi blokira klicno nit brez časovne omejitve. Ob uspehu vrne vrednost tipa V, ki je lahko null, če je bil to rezultat opravila.
Če opravilo sproži izjemo, get() sproži ExecutionException. Prvotno izjemo lahko pridobiš z getCause(). Nasprotno InterruptedException pomeni, da je bila med čakanjem prekinjena klicna nit, ne pa, da opravilo ni uspelo. Če je bilo opravilo preklicano, get() sproži nepreverjano izjemo CancellationException.
Preobremenjena različica get(long timeout, TimeUnit unit) ima enake možne izide, vendar omeji čas čakanja. Če časovna omejitev poteče med čakanjem, sproži TimeoutException. Potek časovne omejitve sam po sebi ne prekliče opravila; get() lahko pozneje pokličeš znova.
Ko se ExecutorService.invokeAll(tasks) normalno vrne, so objekti Future že v končnem stanju in sledijo vrstnemu redu opravil v zbirki. isDone() ne pomeni uspeha: izjemo opravila sporoči get() na njegovem objektu Future kot ExecutionException, ne pa sam invokeAll. Sam klic invokeAll je lahko med čakanjem prekinjen (InterruptedException) ali pa katerega od opravil ni mogoče razporediti za izvajanje (RejectedExecutionException). Različica invokeAll s časovno omejitvijo pred vrnitvijo prekliče nedokončana opravila; get() na preklicanem objektu Future sproži CancellationException.
Primeri
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class FutureGetExample {
public static void main(String[] args) throws InterruptedException {
List<Callable<Integer>> tasks = List.of(
() -> 21 * 2,
() -> { throw new IllegalStateException("invalid input"); }
);
try (ExecutorService executor = Executors.newSingleThreadExecutor()) {
List<Future<Integer>> futures = executor.invokeAll(tasks);
System.out.println("invokeAll returned");
for (Future<Integer> future : futures) {
try {
System.out.println("Result: " + future.get());
} catch (ExecutionException e) {
Throwable cause = e.getCause();
System.out.println("Task failed: " + cause.getClass().getSimpleName()
+ ": " + cause.getMessage());
}
}
}
}
}Rezultat
invokeAll returned Result: 42 Task failed: IllegalStateException: invalid input
Prva vrstica pokaže, da se je `invokeAll` normalno vrnil. Prvi `get()` vrne `42`, drugi pa sproži `ExecutionException`. Program izpiše tip in sporočilo vzroka, ne izjeme, ki ga ovija. Stavek try-with-resources zapre izvajalnik.
Povezane lekcije
- Java · Lekcija 50 · Srednja · Različica: 2