Introduzione a Coroutine in Kotlin

Jan 17 2023

Una Coroutine è un thread di esecuzione leggero che può essere sospeso e ripreso in seguito. Ci sono già molti articoli o argomenti che trattano questo argomento, ma questo post è diverso, è semplice e può farti iniziare più facilmente.

Panoramica

Come molti altri linguaggi di programmazione come JS, Python, Coroutine è una funzionalità fornita da Kotlin che ci consente di eseguire attività lunghe e dispendiose in termini di tempo. In breve:

In Kotlin, le Coroutine sono un modo per scrivere codice asincrono e non bloccante in un modo più sequenziale e di facile lettura.

In effetti, niente nuove tecniche qui. Possiamo trattare Kotlin Coroutine come un framework/libreria che incapsula alcuni usi comuni durante la gestione dell'asincronizzazione.

Semplici esempi di utilizzo delle coroutine in Kotlin

Per utilizzare le coroutine in Kotlin, devi includere la kotlinx-coroutines-corelibreria nel tuo progetto. Nel file gradle dell'app (c'è solo un file gradle sotto il progetto IntelliJ o scegli il file gradle per l'app se si tratta di un progetto Android), aggiungi la seguente riga:

dependencies {
    testImplementation(kotlin("test-junit"))
    implementation(kotlin("stdlib-jdk8"))
    // add coroutine dependency
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.2")
}

1. Utilizzare `launch`per creare coroutine

Ecco un esempio di utilizzo di una coroutine per eseguire un'attività di lunga durata in background:

import kotlinx.coroutines.*

fun main() {
    // Start a coroutine using the launch function
    val job = GlobalScope.launch {
        // Perform a long-running task in the background
        delay(1000L)
        println("Hello, world!")
    }

    // Wait for the coroutine to finish
    runBlocking {
        job.join()
    }
}

2. Utilizzare `async`per creare coroutine

Ecco un esempio dell'utilizzo delle coroutine in Kotlin per eseguire più attività in parallelo e quindi attendere che tutte finiscano:

import kotlinx.coroutines.*

fun main() {
    // Start two coroutines using the async function
    val job1 = GlobalScope.async {
        // Perform a long-running task in the background
        delay(1000L)
        println("Task 1")
    }

    val job2 = GlobalScope.async {
        // Perform a different long-running task in the background
        delay(2000L)
        println("Task 2")
    }

    // Wait for both coroutines to finish
    runBlocking {
        job1.await()
        job2.await()
    }
}

La differenza tra launch e async per avviare una coroutine

Entrambi sono comunemente usati per avviare una coroutine. La principale differenza tra i due è che launchrestituisce un Job (futuro cancellabile non bloccante) e non restituisce risultato, mentre asyncrestituisce un Deferred (futuro cancellabile non bloccante con risultato) che può essere utilizzato per ottenere il risultato di la coroutine. Considerando la differenza, quando è necessario utilizzare launch e async per creare le coroutine:

Quando usi launchla funzione, la coroutine verrà eseguita in background e la chiamata alla funzione tornerà immediatamente. Viene utilizzato quando il risultato della coroutine non è necessario.
Quando usi asyncla funzione, anche la coroutine verrà eseguita in background e la chiamata alla funzione tornerà immediatamente, ma restituirà un Deferredoggetto su cui puoi chiamare la funzione .await() per ottenere il risultato della coroutine. Viene utilizzato quando è necessario il risultato della coroutine. Per esempio:

val result = GlobalScope.async {
        return@async URL("https://api.example.com/data").readText()
    }
val data = result.await()
println(data)
// output: {"fact":"A group of cats is called a \u201cclowder.\u201d","length":38}

Cosa c'è di più da qui? Come sappiamo, Coroutine è un argomento importante e poche persone possono spiegarlo tutto. Questo è il primo articolo della serie Coroutine. Se sei interessato, iscriviti per altri prossimi post su questo: