Cosa sono le coroutine?

Le coroutine aiutano a gestire attività di lunga durata che potrebbero altrimenti bloccare il thread principale e causare la mancata risposta dell'app. Una coroutine è un modello di progettazione della concorrenza che puoi usare su Android per semplificare il codice che viene eseguito in modo asincrono.

Come vedi nel diagramma sopra, nel tuo thread principale puoi eseguire solo piccole operazioni. Se desideri eseguire operazioni di lunga durata nel tuo thread principale, la tua app potrebbe essere bloccata e lenta. O se crei no. del thread di background/worker, quindi sta arrivando il problema di memoria esaurita. Le coroutine sono un tipo speciale di funzione che cede deliberatamente il controllo al chiamante, ma non termina il suo contesto nel processo, mantenendolo invece in uno stato inattivo.

Come usare Coroutine?

dependencies {
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:x.x.x"
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:x.x.x"
}

• Principale: utilizza il thread dell'interfaccia utente. In Rx è simile a AndroidSchedulers.MainThread()
• Predefinito: utilizzato per attività ad uso intensivo della CPU . Utilizzerà tanti thread quanti sono i core della CPU disponibili. Poiché si tratta di attività che richiedono molta CPU, non ha senso avere molti thread in esecuzione, poiché la CPU sarà occupata. Simile a Schedulers.computation() in Rx.
• IO: utilizzato per Input/Output. Effettuare una richiesta a un'API, accedere a un DB, ecc. Simile a Schedulers.io() in Rx.
• Lavoro: è essenzialmente un'attività che viene eseguita in background e può essere interpretata come un'azione, con un ciclo di vita che viene distrutto una volta terminato.
• Per eseguire diverse operazioni utilizzando i lavori: Job.join
• Per cancellare tutti i lavori figli: Job.cancel
• withContext: un altro modo di scrivere l'async in cui non dobbiamo scrivere await().

suspend fun fetchUser() = withContext(Dispatchers.IO) {
        // make network call
        // return 
}

Suspend : come suggerisce il nome, sono funzioni che sospendono l'esecuzione di una coroutine ad un certo punto, per poi riprendere nuovamente l'esecuzione della funzione quando il risultato è pronto.

suspend fun makeNetworkRequest() {
    // fetchData is another suspend function, so 'makeNetworkRequest' is going to be `suspended`
    // until it's result becomes available, without blocking the main thread.
    val result = fetchData()
    // continues executing once the result becomes available
    show(result)
}

// fetchData is main thread safe
suspend fun fetchData(): Result { ... }

Il lancio non bloccherà il thread principale, ma d'altra parte l'esecuzione della parte restante del codice non attenderà il risultato del lancio poiché il lancio non è una chiamata di sospensione.

fun GFG()
{
    var resultOne = "Android"
    var resultTwo = "Kotlin"
    Log.i("Launch", "Before")
    launch(Dispatchers.IO) { resultOne = function1() }
    launch(Dispatchers.IO) { resultTwo = function2() }
    Log.i("Launch", "After")
    val resultText = resultOne + resultTwo
    Log.i("Launch", resultText)
}

suspend fun function1(): String
{
    delay(1000L)
    val message = "function1"
    Log.i("Launch", message)
    return message
}

suspend fun function2(): String
{
    delay(100L)
    val message = "function2"
    Log.i("Launch", message)
    return message
}

Async viene utilizzato anche per avviare le coroutine, ma blocca il thread principale nel punto di ingresso della funzione await() nel programma.

fun GFG
{
    Log.i("Async", "Before")
    val resultOne = Async(Dispatchers.IO) { function1() }
    val resultTwo = Async(Dispatchers.IO) { function2() }
    Log.i("Async", "After")
    val resultText = resultOne.await() + resultTwo.await()
    Log.i("Async", resultText)
}

suspend fun function1(): String
{
    delay(1000L)
    val message = "function1"
    Log.i("Async", message)
    return message
}

suspend fun function2(): String
{
    delay(100L)
    val message = "function2"
    Log.i("Async", message)
    return message
}

Vantaggi utilizzando Coroutines

• Le coroutine sono thread leggeri
• Le coroutine possono funzionare in parallelo, aspettarsi l'una con l'altra e comunicare tra loro
• Crea migliaia di coroutine senza alcun problema di memoria
• Ideale per applicazioni moderne