0Pricing
Java Academy · Lezione

Creazione e completamento di CompletableFuture

Utilizzi supplyAsync, runAsync e completedFuture e completi manualmente i future con complete e completeExceptionally.

Creazione e completamento di CompletableFuture è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.

Che cos'è CompletableFuture?

CompletableFuture<T> (Java 8+) rappresenta un calcolo asincrono che può essere completato, concatenato e combinato esplicitamente. Implementa sia Future sia CompletionStage.

supplyAsync: avviare un calcolo asincrono

CompletableFuture.supplyAsync() esegue un Supplier nel ForkJoinPool comune e restituisce un future contenente il risultato.

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    // runs on ForkJoinPool.commonPool()
    return fetchDataFromNetwork();
});
System.out.println("Non-blocking — this runs immediately");

runAsync: avviare senza attendere il risultato

runAsync() esegue un Runnable in modo asincrono e restituisce CompletableFuture<Void>. Lo utilizzi quando non ha bisogno di un risultato.

CompletableFuture<Void> task = CompletableFuture.runAsync(() ->
    sendEmail("user@example.com", "Welcome!"));
task.thenRun(() -> System.out.println("Email sent"));

Executor personalizzato

Passi un Executor personalizzato per controllare il pool di thread utilizzato dal calcolo: è essenziale nelle applicazioni web quando desidera evitare di bloccare il pool comune.

ExecutorService pool = Executors.newFixedThreadPool(10);
CompletableFuture<User> future = CompletableFuture.supplyAsync(
    () -> userService.findById(42L), pool
);

completedFuture: valore già completato

CompletableFuture.completedFuture(value) restituisce un future già completato. È utile nei test o quando dispone di un valore immediato da restituire in una pipeline asincrona.

CompletableFuture<String> cached = CompletableFuture.completedFuture("cached-value");
cached.thenAccept(System.out::println); // runs immediately

Completare manualmente un future

Utilizzi complete() per fornire il risultato dall'esterno del calcolo. Utilizzi completeExceptionally() per segnalare un errore.

CompletableFuture<String> promise = new CompletableFuture<>();
// In another thread or callback:
promise.complete("done!");       // signals success
// promise.completeExceptionally(new RuntimeException("fail")); // signals failure
String result = promise.get();   // blocks until completed

get() e join()

Sia get() sia join() bloccano l'esecuzione finché il future non viene completato. get() genera eccezioni controllate, mentre join() le racchiude nella CompletionException non controllata.

try {
    String r = future.get(5, TimeUnit.SECONDS); // checked exceptions
} catch (TimeoutException | InterruptedException | ExecutionException e) { ... }
// Or:
String r = future.join(); // throws CompletionException (unchecked)

get() per una verifica non bloccante

getNow(defaultValue) restituisce il risultato se il future è già completato oppure il valore predefinito fornito in caso contrario: non blocca e non attende.

String result = future.getNow("loading...");
System.out.println(result); // "loading..." if not yet done

isDone, isCancelled, isCompletedExceptionally

Verifichi lo stato di un future senza bloccare l'esecuzione. Combini queste verifiche nei cicli di polling o nel codice di monitoraggio.

if (future.isDone())                    System.out.println("Completed");
if (future.isCancelled())               System.out.println("Cancelled");
if (future.isCompletedExceptionally()) System.out.println("Failed");

cancel() per gestire i timeout

Chiami cancel(true) per annullare un calcolo in corso. Il future passa allo stato annullato e qualsiasi get() bloccante genera una CancellationException.

CompletableFuture<String> future = fetchAsync();
ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
scheduler.schedule(() -> future.cancel(true), 3, TimeUnit.SECONDS);

completeOnTimeout (Java 9+)

completeOnTimeout(value, timeout, unit) completa automaticamente il future con un valore predefinito se non viene completato entro il timeout: è più semplice di un annullamento manuale.

CompletableFuture<String> result = fetchAsync()
    .completeOnTimeout("default", 3, TimeUnit.SECONDS);
System.out.println(result.join()); // "default" if fetch took > 3s

Verifica rapida

Quale metodo avvia un calcolo asincrono nel ForkJoinPool comune e restituisce un valore?

Riepilogo

supplyAsync / runAsync avviano il lavoro asincrono. complete / completeExceptionally completano manualmente il future. Utilizzi join() per un blocco con eccezioni non controllate. completeOnTimeout gestisce i timeout in modo semplice.

Domande Frequenti

La lezione «Creazione e completamento di CompletableFuture» è gratuita?

Sì — il testo completo di «Creazione e completamento di CompletableFuture» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.

Cosa imparerò in «Creazione e completamento di CompletableFuture»?

Utilizzi supplyAsync, runAsync e completedFuture e completi manualmente i future con complete e completeExceptionally. Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Java Academy?

Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Creazione e completamento di CompletableFuture»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Java Academy?

Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Creazione e completamento di CompletableFuture
  2. Concatenare con thenApply e thenCompose
  3. Combinare i future: allOf e anyOf
  4. Gestione degli errori e pipeline HTTP asincrona
← Torna a Java Academy