Kotlin Nebenläufigkeit: Threads, Coroutinen und async/await für Anfänger

Kotlin vs Python: Wer gewinnt? Der Kampf um die Nebenläufigkeit

Wenn Sie diesen Artikel auf PythonLib lesen, sind Sie wahrscheinlich bereits mit Python und seinem GIL (Global Interpreter Lock) vertraut, der Multithreading zu einer Kopfschmerz-Angelegenheit macht. Sie schreiben threading, hoffen auf einen Geschwindigkeitszuwachs und erhalten... synchronen Code mit einem Hauch von Sperren. Kommt Ihnen das bekannt vor?

Willkommen in der Welt von Kotlin! Dies ist eine Sprache, die beschlossen hat: „Lasst uns Nebenläufigkeit bequem, schnell und schmerzfrei machen.“ In diesem Artikel werden wir drei Ansätze zur Nebenläufigkeit in Kotlin untersuchen: klassische Threads, moderne Coroutinen und das leistungsstarke Duo async/await. Sie erfahren, wie Sie asynchronen Code schreiben, der den Verstand nicht sprengt, und warum Kotlin eine ausgezeichnete Wahl für die Backend- und Android-Entwicklung ist.

1. Threads in Kotlin: Alter Freund besser als neue?

Beginnen wir mit den Grundlagen. Threads in Kotlin sind dieselben Threads wie in Java. Kotlin läuft auf der JVM, daher haben Sie Zugriff auf die gesamte Leistungsfähigkeit von java.lang.Thread. Aber seien wir ehrlich: Threads sind wie Autofahren ohne Airbags. Es funktioniert, aber es ist beängstigend.

Wie erstellt man einen Thread in Kotlin?

Der einfachste Weg:

fun main() {\n    thread {\n        println("Hallo aus dem Thread: ${Thread.currentThread().name}")\n    }\n    println("Hauptthread: ${Thread.currentThread().name}")\n}

Sieht vertraut aus, oder? Aber es gibt einen Haken: Threads sind schwergewichtig. Jeder Thread ist eine separate Systemressource. Wenn Sie 10.000 Threads erstellen, stürzt Ihr Programm entweder mit einem OutOfMemoryError ab oder wird so langsam wie ein alter Computer mit Windows 95.

Probleme mit Threads:

\n
• Hoher Speicherverbrauch – jeder Thread reserviert einen Stack (~1 MB).
\n
• Komplexität der Synchronisation – Sperren, Deadlocks, Race Conditions. Erinnern Sie sich an synchronized in Java und weinen Sie.
\n
• Kontextwechsel – das Betriebssystem verbringt Zeit mit dem Wechsel zwischen Threads.
\n

Für kleine Projekte sind Threads in Ordnung. Aber wenn Sie einen hochbelasteten Dienst oder eine Anwendung mit Tausenden von parallelen Aufgaben bauen, ist es Zeit, sich Coroutinen anzusehen.

2. Coroutinen in Kotlin: Leicht wie eine Feder

Coroutinen sind „Threads auf Steroiden“. Sie sind nicht an System-Threads gebunden und können auf einem einzigen Thread ausgeführt werden, wobei sie zwischen Aufgaben wechseln, ohne dass das Betriebssystem eingreift. Klingt kompliziert? In der Praxis ist es einfach und elegant.

Die erste Coroutine

Um mit Coroutinen zu arbeiten, benötigen Sie die Abhängigkeit kotlinx-coroutines-core. Aber wenn Sie Kotlin 1.3+ verwenden, ist sie bereits integriert.

import kotlinx.coroutines.*\n\nfun main() = runBlocking {\n    launch {\n        delay(1000L)\n        println("Welt nach der Verzögerung!")\n    }\n    println("Hallo,")\n}

Was passiert hier?

\n
• runBlocking – blockiert den Hauptthread, bis alle Coroutinen darin abgeschlossen sind. Für das Lernen in Ordnung, für die Produktion mit Vorsicht verwenden.
\n
• launch – startet eine neue Coroutine. Sie blockiert den Thread nicht, sondern pausiert einfach bei delay.
\n
• delay – das Analogon zu Thread.sleep(), aber nicht blockierend. Die Coroutine „schläft“ einfach und gibt den Thread für andere Aufgaben frei.
\n

Ergebnis: Zuerst wird „Hallo,“ ausgegeben, und nach einer Sekunde „Welt nach der Verzögerung!“. Ohne Blockaden, ohne unnötige Threads.

Warum sind Coroutinen besser als Threads?

\n
• Leichtgewichtig – Eine Million Coroutinen? Kein Problem! Sie erstellen keine separaten Threads.
\n
• Aussetzung (Suspension) – Eine Coroutine kann jederzeit anhalten und später fortgesetzt werden.
\n
• Strukturierte Nebenläufigkeit – Coroutinen leben in einem Gültigkeitsbereich (Scope) und werden automatisch abgebrochen, wenn der Scope endet.
\n

Dispatchers