Ce este o coroutine în Kotlin și cum funcționează?

Coroutine în Kotlin este o unitate ușor de execuție care permite scrierea de cod asincron și non-blocant într-un mod mai lizibil și secvențial. Este similar cu un thread, dar mult mai ușor și poate fi creat în cantități mari.

Componentele principale și principiile de funcționare:

• Funcții Suspendate: Funcții marcate cu cuvântul cheie suspend, care pot suspenda execuția lor fără a bloca thread-ul pe care rulează. Când o funcție suspendată își încheie operațiunea de "așteptare" (de exemplu, o solicitare de rețea), poate relua execuția de unde a fost suspendată.
• Contextul (Contextul Coroutine): Un set de elemente care controlează comportamentul coroutinei. Include:
  • Job: Descriptorul coroutinei, care permite gestionarea ciclului său de viață (anulare, așteptare pentru finalizare).
  • CoroutineDispatcher: Definește thread-urile pe care va fi executată corutina. Permite comutarea între thread-uri.
  • CoroutineName: Nume opțional pentru depanare.
  • CoroutineExceptionHandler: Handler pentru excepții necontrolate.
• Constructorii (Builders): Funcții care pornesc execuția corutinelor:
  • launch: Pornește o nouă corutină fără a returna rezultat. Returnează un Job.
  • async: Pornește o nouă corutină care returnează un rezultat (Deferred). Pentru a obține rezultatul, se folosește .await().
  • runBlocking: Constructor blocant, utilizat în principal pentru testare sau integrare cu cod blocant.

Cum funcționează în spate:

Corutinele nu creează thread-uri separate pentru fiecare sarcină. În schimb, atunci când o funcție suspend este suspendată, compilatorul generează cod care salvează starea curentă a calculelor. Când rezultatul este disponibil, corutina este reluată pe unul dintre thread-urile gestionate de CoroutineDispatcher. Acest lucru se realizează transformând funcțiile suspend în apeluri asincrone cu continuări, permițând unui thread să execute multiple corutine, schimbând între ele la suspendare.

Exemplu:

import kotlinx.coroutines.*

fun main() = runBlocking { // Blochează thread-ul curent până când corutina din runBlocking se finalizează
    println("Mai întâi")

    launch { // Pornește o nouă corutină în fundal
        delay(1000L) // Întârziere non-blocantă de 1 secundă
        println("După întârziere")
    }

    println("Apoi") // Această linie va fi executată înainte ca launch să se termine
}

Ieșirea acestui cod va fi:

Mai întâi
Apoi
După întârziere

Aceasta demonstrează natura non-blocantă a launch și delay.