# Compito
Immagina di **organizzare** un grande **evento di beneficenza** e di dover **conteggiare** tutte le **donazioni** ricevute. Hai un **elenco** di importi donati e vuoi conoscere la **somma totale** di tutte le donazioni. Per rendere questo compito più gestibile, decidi di **dividere** l'elenco in parti più piccole e di distribuire questi **segmenti** tra i tuoi **amici** per **aiutarti nel conteggio**. Ogni amico **calcola** l'importo totale per **la propria parte assegnata** e ti comunica il risultato. Successivamente, **combini** tutti questi risultati per ottenere il **totale finale**.

Hai una **classe** `DonationTask` che estende `RecursiveTask<Long>`. Devi **sovrascrivere** il **metodo** `compute()` in questa classe per implementare la logica di **suddivisione** dell'elenco delle donazioni e calcolo degli importi.

La **classe** `DonationTask` include un campo costante `THRESHOLD` impostato a **200**. Questa **soglia** specifica il numero massimo di donazioni che un **singolo segmento** dovrebbe contenere. **Non modificare questa soglia.**

**Ad esempio**, se inizi con un elenco di **1.000** donazioni, dovresti suddividerlo in segmenti da **200** o meno donazioni ciascuno. Poi, **calcola** l'importo totale sommando i **risultati di ciascun segmento**.

 - `THRESHOLD` - soglia per la suddivisione dell'array;
- `long[] listDonations` - array sorgente con tutte le donazioni;
- `int start` - inizio dell'array;
- `int end` - fine dell'array.


Esiste anche una **classe** `RunnableTask` dove **viene eseguito il programma**. Qui **inizializziamo** la nostra lista ed eseguiamo il tutto in un `ForkJoinPool`. Una volta che tutto è operativo, **visualizziamo il risultato**.

Se si **implementa** correttamente il metodo `compute()`, si dovrebbe ottenere la **somma totale**:

# Suggerimenti per la soluzione

Nel **metodo** `compute()`, è necessario verificare se la **dimensione** del nostro array **(donation list)** è inferiore alla soglia corrente, `THRESHOLD`. Se è inferiore, ottimo; si cicla semplicemente su tutti gli **elementi** di questo array **(donation list)**, si sommano e si **restituisce il risultato**.

Se la dimensione è maggiore, bisogna trovare la **metà dell'array** e processare ricorsivamente i lati **sinistro** e **destro** dell'array (come se si stesse dividendo la lista tra amici).

Per fare ciò, si **creano 2** oggetti `DonationTask`, si passano i limiti dell'array e l'array stesso come **parametri**, quindi si richiama il metodo `fork()` su questi oggetti. Infine, si ottiene il risultato della **somma** richiamando `join()` su ciascun task, si sommano i risultati e si **restituisce** il totale.

Sembra piuttosto complicato, ma in realtà basta comprendere e implementare l'illustrazione sopra!

Nota

**Sono sicuro che puoi farcela!** Ma se hai difficoltà, puoi consultare la **soluzione**.

Una volta che sei sicuro che **tutto funzioni**, esegui i test di verifica nel percorso `/src/test/java/TaskForkJoinTest.java`.

Questo corso è pensato per chi desidera ampliare le proprie conoscenze sul multithreading e sfruttarne le potenzialità per sviluppare applicazioni efficienti e ad alte prestazioni. Verranno approfonditi concetti fondamentali, tecniche pratiche e best practice nel multithreading, consentendo di affrontare con sicurezza le problematiche complesse di concorrenza.

Questa sezione approfondirà i concetti fondamentali del multithreading in Java, concentrandosi sulla creazione e gestione dei thread e sull'uso di tecniche di sincronizzazione per evitare conflitti. Verrà inoltre illustrato come utilizzare parole chiave e metodi essenziali per garantire l'esecuzione accurata e affidabile dei programmi multithread, fornendo una solida comprensione di come gestire efficacemente la concorrenza nelle applicazioni.

Questa sezione esamina le collezioni sincronizzate in Java, spiegando il loro scopo e le comuni problematiche di concorrenza che sono progettate per risolvere. Verranno approfonditi il funzionamento di queste collezioni, la loro importanza negli ambienti multithread e il modo in cui contribuiscono a garantire una manipolazione sicura e coerente dei dati quando più thread accedono a risorse condivise.

Questa sezione tratta i meccanismi di sincronizzazione di alto livello in Java, come l'utilizzo di Lock e Condition, semafori, barriere, variabili atomiche e thread pooling con Executors. Ogni argomento è accompagnato da esercizi pratici progettati per rafforzare la comprensione e aiutare ad applicare le conoscenze teoriche a scenari reali.

Questa sezione esplora i principali pattern e pratiche di programmazione multithread come Producer-Consumer, Fork/Join, ThreadLocal e la programmazione asincrona con CompletableFuture. Verranno analizzati esempi pratici e i risultati concreti di questi approcci, offrendo un'esperienza diretta che consentirà di applicare efficacemente queste tecniche in applicazioni reali.

Sfida: Forkjoinpool

Sfida: Forkjoinpool