Java Academy · Lezione

StructuredTaskScope

Eseguire e riunire le sottoattività

StructuredTaskScope è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 2 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.

Introduzione a StructuredTaskScope

StructuredTaskScope è l'API principale della concorrenza strutturata. Apre uno scope, esegue il fork delle sottoattività, usa join per attenderle e poi ne legge i risultati.

È una funzionalità in anteprima, quindi compili ed esegua il programma con --enable-preview.

Ciclo di vita di base

Ogni utilizzo segue lo stesso ritmo in quattro passaggi:

Apra lo scope in un blocco try-with-resources
Esegua il fork di una o più sottoattività, ognuna delle quali restituisce un handle Subtask
Usi join per attenderne il completamento
Legga il risultato di ogni sottoattività tramite get()

fork restituisce un handle

fork(Callable) avvia immediatamente la sottoattività su un thread virtuale e restituisce un Subtask. Non deve chiamare il suo get() prima che join() abbia restituito il controllo.

Un esempio completo

Qui due sottoattività vengono eseguite in parallelo. Entrambe devono terminare prima di poter leggere i risultati. L'esempio usa ShutdownOnFailure, una politica integrata.

import java.util.concurrent.StructuredTaskScope;

public class Main {
    public static void main(String[] args) throws Exception {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            var name = scope.fork(() -> "Grace");
            var count = scope.fork(() -> 3);
            scope.join();
            scope.throwIfFailed();
            System.out.println(name.get() + " placed " + count.get() + " orders");
        }
    }
}

Esegua join, poi legga

L'ordine è rigoroso: fork, poi join, poi get. Chiamare get() su una sottoattività prima del completamento di join() genera IllegalStateException.

Questa regola mantiene strutturata la durata delle attività.

Stati delle sottoattività

Dopo join(), ogni Subtask restituisce uno state():

SUCCESS con un risultato ottenuto da get()
FAILED con l'eccezione ottenuta da exception()
UNAVAILABLE se non è mai stato completato

Molte sottoattività

Può eseguire il fork di tutte le sottoattività che desidera; ognuna riceve il proprio thread virtuale. È così che distribuisce il lavoro di un gruppo di chiamate indipendenti.

import java.util.*;
import java.util.concurrent.StructuredTaskScope;

public class Main {
    public static void main(String[] args) throws Exception {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            List<StructuredTaskScope.Subtask<Integer>> tasks = new ArrayList<>();
            for (int i = 1; i <= 5; i++) {
                final int n = i;
                tasks.add(scope.fork(() -> n * n));
            }
            scope.join();
            scope.throwIfFailed();
            int total = tasks.stream().mapToInt(StructuredTaskScope.Subtask::get).sum();
            System.out.println("Sum of squares 1..5 = " + total);
        }
    }
}

Lo scope gestisce i thread

Lo scope è un AutoCloseable. Quando termina il blocco try, close() garantisce che ogni thread delle sottoattività sia terminato. Non sono possibili perdite.

Per questo lo si usa sempre all'interno di try-with-resources.

Politiche integrate

Il JDK include due politiche di arresto già pronte:

ShutdownOnFailure: annulla le attività rimanenti se una sottoattività fallisce
ShutdownOnSuccess: annulla le attività rimanenti non appena una ha esito positivo

Può anche estendere StructuredTaskScope per implementare una logica personalizzata.

Solo il thread proprietario esegue join

Solo il thread che ha aperto lo scope può eseguire il fork al suo interno e chiamare join. Le sottoattività sono vincolate allo scope che le possiede, mantenendo così l'albero ben formato.

Flag per compilazione ed esecuzione

Poiché l'API è in anteprima, compili con:

javac --release 21 --enable-preview Main.java
java --enable-preview Main

Senza il flag si verifica un errore di compilazione o di esecuzione.

Verifica rapida

Ricordi l'ordine obbligatorio delle chiamate.

Riepilogo

Ha imparato a usare l'API StructuredTaskScope:

La apra in try-with-resources, esegua fork, poi join e infine get
Ogni sottoattività viene eseguita sul proprio thread virtuale
Lo scope garantisce che tutte le sottoattività terminino prima della chiusura
Richiede --enable-preview

Prossimo argomento: le politiche shutdown-on-failure e shutdown-on-success in dettaglio.

Domande Frequenti

La lezione «StructuredTaskScope» è gratuita?

Sì — il testo completo di «StructuredTaskScope» è 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 «StructuredTaskScope»?

Eseguire e riunire le sottoattività 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 2 di 4.

Quanto tempo richiede la lezione «StructuredTaskScope»?

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

← Torna a Java Academy