Hogyan valósítható meg a több szálas végrehajtás…

A Kotlinban a több szálú végrehajtás többféleképpen valósítható meg:

Szokásos Java szálak (Threads):

// Runnable interfész megvalósítása
class MyRunnable : Runnable {
    override fun run() {
        // Kód, amely külön szálon fut
        println("Üdv a szálból: ${Thread.currentThread().name}")
    }
}

fun main() {
    // Runnable példány létrehozása
    val runnable = MyRunnable()
    // Thread objektum létrehozása a Runnable-ból
    val thread = Thread(runnable)
    // Szál indítása
    thread.start()
}

Vagy lambda kifejezéssel:

fun main() {
    val thread = Thread {
        // Kód, amely külön szálon fut
        println("Üdv a szálból: ${Thread.currentThread().name}")
    }
    thread.start()
}

Kotlin Coroutines (Korrutínok): Ez a javasolt és modernebb megközelítés Kotlinban, könnyűsúlyú több szálú végrehajtást biztosít.

import kotlinx.coroutines.*

fun main() = runBlocking {
    // Új korutina létrehozása globális scope-ban
    launch {
        delay(1000L) // Nem blokkoló késleltetés 1 másodpercig
        println("Üdv a korutínából")
    }
    // A fő szál folytatódik
    println("Üdv a fő szálból")
    // runBlocking várja az összes belső korutina befejeződését
}

Különböző korutin építők példái:

launch: Új korutina indítása visszatérési érték nélkül.

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        println("Ez a korutina egyszerűen végrehajt egy műveletet")
    }
}

async: Új korutina indítása, eredményt ad vissza Deferred-en keresztül.

import kotlinx.coroutines.*

fun main() = runBlocking {
    val deferredResult = async {
        delay(1000L)
        "Eredmény a korutínából"
    }
    val result = deferredResult.await() // Eredmény várása
    println(result)
}

RxKotlin/RxJava: A reaktív programozás lehetővé teszi aszinkron műveletek és több szál kezelését is, ütemezőket (Schedulers) használva.

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

fun main() {
    Observable.just("Aszinkron elem")
        .subscribeOn(Schedulers.io()) // Feliratkozás I/O szálon
        .observeOn(Schedulers.computation()) // Eredmények megfigyelése számítási szálon
        .subscribe { item ->
            println("Kaptuk: $item a szálon ${Thread.currentThread().name}")
        }

    Thread.sleep(2000) // Várakozás az aszinkron műveletek befejezésére
}

A módszer kiválasztása a konkrét feladattól függ. A modern Kotlin alkalmazásokban a korutínokat részesítik előnyben könnyűsúlyuk, egyszerű használatuk és a nyelvbe való beépített támogatásuk miatt. A Java szálak inkább alacsony szintű kontrollhoz, míg az reaktív könyvtárak adatfolyamok kezeléséhez alkalmasak.

Hogyan valósítható meg a több szálas végrehajtás Kotlinben?