Quali capacità offre Kotlin per lavorare con…

Kotlin fornisce coroutine per semplificare le operazioni asincrone, offrendo thread leggeri che non bloccano il thread principale.

Funzionalità chiave:

Funzioni di sospensione: Funzioni con la parola chiave suspend, che possono essere sospese e riprese. Non bloccano il thread in cui vengono eseguite.
```
suspend fun fetchData(): String {
    delay(1000) // Simula un'operazione lunga
    return "Dati ricevuti"
}
```
Costruttori di coroutine: Funzioni usate per avviare coroutine:
- launch: Avvia una nuova coroutine e restituisce un Job (non bloccante).
```
GlobalScope.launch {
    println("Coroutine avviata")
}
```
- async: Avvia una nuova coroutine e restituisce un Deferred<T> (bloccante alla chiamata di .await()).
```
val deferred = GlobalScope.async {
    fetchData()
}
// ...
val result = deferred.await() // Attende il risultato
```
- runBlocking: Blocca il thread corrente fino al completamento della coroutine (usato in ponti tra codice bloccante e non, ad esempio nei test).
```
runBlocking {
    val data = fetchData()
    println(data)
}
```
Contesto di coroutine: Insieme di elementi che definiscono il comportamento della coroutine, incluso Dispatcher e Job.
- Dispatcher: Determina il thread o il pool di thread in cui viene eseguita la coroutine.
Dispatchers: Oggetti integrati per gestire i thread:
- Dispatchers.Default: Pool condiviso di thread di background.
- Dispatchers.IO: Ottimizzato per input/output (operazioni su disco, rete).
- Dispatchers.Main: Thread principale dell'interfaccia utente (per Android, JavaFX, ecc.).
- Dispatchers.Unconfined: Esegue la coroutine nel thread corrente, ma può riprenderla in qualsiasi thread dopo la sospensione.
```
GlobalScope.launch(Dispatchers.IO) {
    // Esegue nel thread di input/output
}
```

Concorrenza strutturata: Principio secondo cui le coroutine hanno un genitore (CoroutineScope) e vengono cancellate automaticamente alla cancellazione del genitore. Previene perdite di risorse e semplifica la gestione del ciclo di vita.

// CoroutineScope gestisce automaticamente le coroutine figlie
val scope = CoroutineScope(Dispatchers.Default)
val job = scope.launch {
    // ...
}
// Alla cancellazione dello scope, tutte le coroutine figlie vengono cancellate
scope.cancel()

Canali: Per il trasferimento sicuro di dati tra coroutine. Possono essere:
- Unbuffered: La ricezione avviene solo dopo l'invio.
- Buffered: Permette di inviare più elementi prima di bloccare.
- Conflated: Memorizza solo l'ultimo elemento inviato.
```
val channel = Channel<Int>()

scope.launch {
    for (x in 1..5) channel.send(x)
    channel.close()
}

scope.launch {
    for (y in channel) println(y)
}
```

Flow: Flusso di dati che può emettere più valori asincroni. Simile a RxJava Observable, ma più leggero e integrato con le coroutine.

fun simpleFlow(): Flow<Int> = flow {
    for (i in 1..3) {
        delay(100)
        emit(i) // Invio del valore
    }
}

runBlocking {
    simpleFlow().collect { value -> println(value) } // Consumo dei valori
}

Queste funzionalità consentono di scrivere codice asincrono in stile imperativo, rendendolo più leggibile e manutenibile rispetto all'uso di callback o Future.

Quali capacità offre Kotlin per lavorare con operazioni asincrone?