Wie implementiert man Multithreading in Kotlin…

Multithreading in Kotlin kann auf verschiedene Weisen implementiert werden:

Standard-Java-Threads:

// Implementieren des Runnable-Interfaces
class MyRunnable : Runnable {
    override fun run() {
        // Code, der in einem separaten Thread ausgeführt wird
        println("Hallo vom Thread: ${Thread.currentThread().name}")
    }
}

fun main() {
    // Erstellen einer Runnable-Instanz
    val runnable = MyRunnable()
    // Erstellen eines Thread-Objekts mit Runnable
    val thread = Thread(runnable)
    // Thread starten
    thread.start()
}

Oder mit einer Lambda-Ausdruck:

fun main() {
    val thread = Thread {
        // Code, der in einem separaten Thread ausgeführt wird
        println("Hallo vom Thread: ${Thread.currentThread().name}")
    }
    thread.start()
}

Kotlin Coroutines: Dies ist ein empfohlener und moderner Ansatz in Kotlin, der leichtgewichtige Multithreading ermöglicht.

import kotlinx.coroutines.*

fun main() = runBlocking {
    // Erstellen einer neuen Coroutine im globalen Scope
    launch {
        delay(1000L) // Nicht blockierende Verzögerung von 1 Sekunde
        println("Hallo aus der Coroutine")
    }
    // Der Haupt-Thread fährt fort
    println("Hallo vom Haupt-Thread")
    // runBlocking wartet auf den Abschluss aller Kind-Coroutines
}

Beispiele für verschiedene Coroutine-Bausteine:

launch: Startet eine neue Coroutine ohne Rückgabewert.

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        println("Diese Coroutine führt einfach eine Aktion aus")
    }
}

async: Startet eine neue Coroutine, die ein Ergebnis mit Deferred zurückgibt.

import kotlinx.coroutines.*

fun main() = runBlocking {
    val deferredResult = async {
        delay(1000L)
        "Ergebnis aus der Coroutine"
    }
    val result = deferredResult.await() // Ergebnis abwarten
    println(result)
}

RxKotlin/RxJava: Reaktive Programmierung ermöglicht ebenfalls die Arbeit mit asynchronen Operationen und Multithreading, unter Verwendung von Schedulern.

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

fun main() {
    Observable.just("Asynchrones Element")
        .subscribeOn(Schedulers.io()) // Abonnieren im I/O-Thread
        .observeOn(Schedulers.computation()) // Ergebnisse im Berechnungs-Thread beobachten
        .subscribe { item ->
            println("Empfangen: $item auf Thread ${Thread.currentThread().name}")
        }

    Thread.sleep(2000) // Warten auf Abschluss der asynchronen Operationen
}

Die Wahl der Methode hängt von der konkreten Aufgabe ab. Für die meisten modernen Kotlin-Anwendungen sind Coroutines aufgrund ihrer Leichtgewichtigkeit, einfachen Handhabung und integrierten Unterstützung in der Sprache vorzuziehen. Java-Threads können für eine niedrigere Kontrolle geeignet sein, und reaktive Bibliotheken für die Arbeit mit Datenströmen.

Wie implementiert man Multithreading in Kotlin?