Jak implementovat vícenásobné vlákno v Kotlinu…

Paralelní zpracování v Kotlinu lze realizovat několika způsoby:

Standardní Java vlákna (Threads):

// Implementace rozhraní Runnable
class MyRunnable : Runnable {
    override fun run() {
        // Kód, který poběží v samostatném vlákně
        println("Ahoj z vlákna: ${Thread.currentThread().name}")
    }
}

fun main() {
    // Vytvoření instance Runnable
    val runnable = MyRunnable()
    // Vytvoření objektu Thread s Runnable
    val thread = Thread(runnable)
    // Spuštění vlákna
    thread.start()
}

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

fun main() {
    val thread = Thread {
        // Kód, který poběží v samostatném vlákně
        println("Ahoj z vlákna: ${Thread.currentThread().name}")
    }
    thread.start()
}

Kotlin Coroutines (Korutiny): Jedná se o doporučený a modernější přístup v Kotlinu, který poskytuje lehké vlákna.

import kotlinx.coroutines.*

fun main() = runBlocking {
    // Vytvoření nové korutiny v globálním scope
    launch {
        delay(1000L) // Neblokující zpoždění na 1 sekundu
        println("Ahoj z korutiny")
    }
    // Hlavní vlákno pokračuje
    println("Ahoj z hlavního vlákna")
    // runBlocking čeká na dokončení všech vnořených korutin
}

Příklady použití různých stavitelů korutin:

launch: Spouští novou korutinu bez návratové hodnoty.

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        println("Tato korutina pouze provádí akci")
    }
}

async: Spouští novou korutinu, která vrací výsledek pomocí Deferred.

import kotlinx.coroutines.*

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

RxKotlin/RxJava: Reaktivní programování umožňuje pracovat s asynchronními operacemi a více vlákny pomocí plánovačů (Schedulers).

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

fun main() {
    Observable.just("Asynchronní prvek")
        .subscribeOn(Schedulers.io()) // Provést předplatné v I/O vlákně
        .observeOn(Schedulers.computation()) // Sledovat výsledky v výpočetním vlákně
        .subscribe { item ->
            println("Získáno: $item na vlákně ${Thread.currentThread().name}")
        }

    Thread.sleep(2000) // Čekání na dokončení asynchronních operací
}

Volba metody závisí na konkrétním úkolu. Pro většinu moderních Kotlin aplikací jsou preferovány korutiny díky jejich lehkosti, jednoduchosti použití a vestavěné podpoře v jazyce. Java vlákna mohou být vhodná pro nízkoúrovňovou kontrolu, zatímco reaktivní knihovny jsou vhodné pro práci s datovými proudy.

Jak implementovat vícenásobné vlákno v Kotlinu?