Ako implementovať viacvláknové spracovanie v Kotlin…

Viacvláknové spracovanie v Kotlinu je možné realizovať niekoľkými spôsobmi:

Štandardné Java vlákna (Threads):

// Implementácia rozhrania Runnable
class MyRunnable : Runnable {
    override fun run() {
        // Kód, ktorý sa bude vykonávať v samostatnom vlákne
        println("Ahoj z vlákna: ${Thread.currentThread().name}")
    }
}

fun main() {
    // Vytvorenie inštancie Runnable
    val runnable = MyRunnable()
    // Vytvorenie objektu Thread s Runnable
    val thread = Thread(runnable)
    // Spustenie vlákna
    thread.start()
}

Alebo s použitím lambda výrazu:

fun main() {
    val thread = Thread {
        // Kód, ktorý sa bude vykonávať v samostatnom vlákne
        println("Ahoj z vlákna: ${Thread.currentThread().name}")
    }
    thread.start()
}

Kotlin Coroutines (Koruťiny): Ide o odporúčaný a modernejší prístup v Kotlin, ktorý poskytuje ľahké vlákna.

import kotlinx.coroutines.*

fun main() = runBlocking {
    // Vytvorenie novej korutiny v globálnom scope
    launch {
        delay(1000L) // Neblokujúce oneskorenie na 1 sekundu
        println("Ahoj z korutiny")
    }
    // Hlavné vlákno pokračuje
    println("Ahoj z hlavného vlákna")
    // runBlocking čaká na dokončenie všetkých vnorených korutín
}

Príklady použitia rôznych staviteľov korutín:

launch: Spúšťa novú korutinu bez návratovej hodnoty.

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        println("Táto korutina jednoducho vykonáva akciu")
    }
}

async: Spúšťa novú korutinu, ktorá vracia výsledok pomocou Deferred.

import kotlinx.coroutines.*

fun main() = runBlocking {
    val deferredResult = async {
        delay(1000L)
        "Výsledok z korutiny"
    }
    val result = deferredResult.await() // Čaká na výsledok
    println(result)
}

RxKotlin/RxJava: Reaktívne programovanie tiež umožňuje pracovať s asynchrónnymi operáciami a viacvláknami pomocou plánovačov (Schedulers).

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

fun main() {
    Observable.just("Asynchrónny prvok")
        .subscribeOn(Schedulers.io()) // Vykonať odber v I/O vlákne
        .observeOn(Schedulers.computation()) // Pozorovať výsledky v výpočtovom vlákne
        .subscribe { item ->
            println("Získané: $item na vlákne ${Thread.currentThread().name}")
        }

    Thread.sleep(2000) // Čakanie na dokončenie asynchrónnych operácií
}

Výber metódy závisí od konkrétneho úlohy. Pre väčšinu moderných Kotlin aplikácií sú preferované korutiny vďaka ich ľahkosti, jednoduchosti použitia a vstavanému podpore v jazyku. Java vlákna môžu byť vhodné pre nižšiu úroveň kontroly, zatiaľ čo reaktívne knižnice sú vhodné pre prácu s dátovými tokmi.

Ako implementovať viacvláknové spracovanie v Kotlin?