Cum se implementează multitreading-ul în Kotlin…

Multithreading în Kotlin poate fi implementat în mai multe moduri:

Thread-uri Java standard (Threads):

// Implementarea interfeței Runnable
class MyRunnable : Runnable {
    override fun run() {
        // Cod care va fi executat într-un thread separat
        println("Salut din thread: ${Thread.currentThread().name}")
    }
}

fun main() {
    // Crearea unei instanțe Runnable
    val runnable = MyRunnable()
    // Crearea unui obiect Thread cu Runnable
    val thread = Thread(runnable)
    // Pornirea thread-ului
    thread.start()
}

Sau folosind o expresie lambda:

fun main() {
    val thread = Thread {
        // Cod care va fi executat într-un thread separat
        println("Salut din thread: ${Thread.currentThread().name}")
    }
    thread.start()
}

Corutine Kotlin: Aceasta este o abordare recomandată și mai modernă în Kotlin, care oferă multitasking ușor.

import kotlinx.coroutines.*

fun main() = runBlocking {
    // Crearea unei noi corutine în scope-ul global
    launch {
        delay(1000L) // Întârziere non-blocantă de 1 secundă
        println("Salut din corutină")
    }
    // Thread-ul principal continuă să funcționeze
    println("Salut din thread-ul principal")
    // runBlocking așteaptă finalizarea tuturor corutinelor copil
}

Exemple de diferiți constructori de corutine:

launch: Pornește o nouă corutină fără valoare de întoarcere.

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        println("Această corutină efectuează doar o acțiune")
    }
}

async: Pornește o nouă corutină care returnează un rezultat folosind Deferred.

import kotlinx.coroutines.*

fun main() = runBlocking {
    val deferredResult = async {
        delay(1000L)
        "Rezultatul din corutină"
    }
    val result = deferredResult.await() // Așteaptă rezultatul
    println(result)
}

RxKotlin/RxJava: Programarea reactivă permite, de asemenea, lucrul cu operații asincrone și multitasking, folosind planificatori (Schedulers).

import io.reactivex.rxjava3.core.Observable
import io.reactivex.rxjava3.schedulers.Schedulers

fun main() {
    Observable.just("Element asincron")
        .subscribeOn(Schedulers.io()) // Abonează-te pe thread-ul I/O
        .observeOn(Schedulers.computation()) // Observă rezultatele pe thread-ul de calcul
        .subscribe { item ->
            println("Primite: $item pe thread ${Thread.currentThread().name}")
        }

    Thread.sleep(2000) // Așteaptă finalizarea operațiilor asincrone
}

Alegerea metodei depinde de sarcina specifică. Pentru cele mai multe aplicații moderne Kotlin, corutinele sunt preferate datorită ușurinței, greutății și suportului încorporat în limbaj. Thread-urile Java pot fi adecvate pentru control de nivel inferior, iar bibliotecile reactive pentru lucrul cu fluxuri de date.

Cum se implementează multitreading-ul în Kotlin?