Cos'è una coroutine in Kotlin e come funziona?

La coroutine in Kotlin è una unità leggera di esecuzione che permette di scrivere codice asincrono e non bloccante in modo più leggibile e sequenziale. È simile a un thread, ma molto più leggera e può essere creata in grande quantità.

Componenti principali e principi di funzionamento:

• Funzioni Suspend (Funzioni Suspend): Funzioni contrassegnate dalla parola chiave suspend, che possono sospendere la loro esecuzione senza bloccare il thread in cui vengono eseguite. Quando una funzione sospesa termina la sua operazione di "attesa" (ad esempio, una richiesta di rete), può riprendere l'esecuzione dal punto in cui era stata sospesa.
• Contesto (Contesto della Coroutine): Insieme di elementi che controllano il comportamento della coroutine. Include:
  • Job: Descrittore della coroutine, che permette di gestire il suo ciclo di vita (annullamento, attesa di completamento).
  • CoroutineDispatcher: Definisce il thread(i) su cui verrà eseguita la coroutine. Permette di passare tra thread.
  • CoroutineName: Nome opzionale per il debug.
  • CoroutineExceptionHandler: Gestore di eccezioni non gestite.
• Costruttori (Builders): Funzioni che avviano l'esecuzione delle coroutines:
  • launch: Avvia una nuova coroutine senza restituire risultato. Restituisce un Job.
  • async: Avvia una nuova coroutine che restituisce un risultato (Deferred). Per ottenere il risultato si usa .await().
  • runBlocking: Costruttore bloccante, usato principalmente per test o integrazione con codice bloccante.

Come funziona sotto il cofano:

Le coroutines non creano thread separati per ogni task. Invece, quando una funzione suspend viene sospesa, il compilatore genera codice che salva lo stato corrente dei calcoli. Quando il risultato è disponibile, la coroutine viene ripresa su uno dei thread gestiti da CoroutineDispatcher. Ciò si ottiene trasformando le funzioni suspend in chiamate asincrone con continuations, consentendo a un singolo thread di eseguire molte coroutines, passando tra loro durante la sospensione.

Esempio:

import kotlinx.coroutines.*

fun main() = runBlocking { // Blocca il thread corrente fino al completamento della coroutine interna a runBlocking
    println("Prima")

    launch { // Avvia una nuova coroutine in background
        delay(1000L) // Ritardo non bloccante di 1 secondo
        println("Dopo il ritardo")
    }

    println("Poi") // Questa riga verrà eseguita prima che la coroutine launch finisca
}

L'output di questo codice sarà:

Prima
Poi
Dopo il ritardo

Questo dimostra la natura non bloccante di launch e delay.