Erstellen und Ausführen von Coroutinen in Kotlin

1. Koroutinen in Kotlin
2. Erstellen Sie ein neues Projekt und fügen Sie Abhängigkeiten in Kotlin hinzu
3. Erstellen und führen Sie Coroutinen sequentiell in Kotlin aus
4. Erstellen und Ausführen von Coroutinen gleichzeitig in Kotlin
5. Fazit

Dieses Tutorial stellt Coroutinen vor und zeigt, wie sie sequentiell oder gleichzeitig mit async- await() in Kotlin ausgeführt werden können.

Koroutinen in Kotlin

Eine Coroutine kann als Prozedur betrachtet werden, mit der Ausnahme, dass sie im Vergleich zu anderen normalen Prozeduren, die nur synchrone Programmierung unterstützen, asynchrone Programmierung unterstützt.

Asynchrone Programmierung ist eine Technik, bei der wir die Ausführung einer Aufgabe an einem bestimmten Punkt aussetzen und die Ausführung an eine andere Aufgabe delegieren können, während die ausgesetzte Aufgabe auf die Ausführung einiger Hintergrundaufgaben wartet. Diese Hintergrundaufgaben können das Lesen eines Datensatzes aus einer Datenbank, das Herunterladen des Inhalts einer Webseite und das Verarbeiten einer Benutzeranfrage von einer Anwendung umfassen.

Bei der synchronen Programmierung wird die Ausführung einer Aufgabe zu keinem Zeitpunkt ausgesetzt und der Thread wird ausschließlich verwendet, bis die Ausführung abgeschlossen ist.

Eine Coroutine repräsentiert diese Instanz einer ausgesetzten Routine. Sie kann auch als Thread betrachtet werden, aber eine Coroutine ist nicht vom zugrunde liegenden Thread abhängig, da sie die Ausführung auf verschiedenen Threads anhalten und fortsetzen kann.

In diesem Tutorial lernen wir, wie man sequentielle und gleichzeitige Coroutinen erstellt, indem man sicherstellt, dass die async- await()-Funktionen in der richtigen Reihenfolge ausgeführt werden.

Erstellen Sie ein neues Projekt und fügen Sie Abhängigkeiten in Kotlin hinzu

Gehen Sie zu IntelliJ und wählen Sie Datei > Neu > Projekt. Geben Sie im sich öffnenden Fenster als Projektnamen kotlinCoroutines ein, wählen Sie Kotlin im Abschnitt Sprache, Gradle im Abschnitt Build System und klicken Sie auf die Schaltfläche Erstellen.

Um mit Coroutinen in Kotlin zu arbeiten, müssen wir die Coroutine-Abhängigkeiten zu unserer Anwendung hinzufügen. Gehen Sie zur Datei build.gradle.kts und stellen Sie sicher, dass Sie die folgenden Abhängigkeiten haben.

dependencies {
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.2")
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.2")
    testImplementation(kotlin("test"))
}

Stellen Sie sicher, dass Sie über eine aktive Internetverbindung verfügen, um die Abhängigkeiten herunterzuladen. Laden Sie nach dem Herunterladen der Abhängigkeiten die Gradle-Änderungen und fahren Sie mit den nächsten Schritten fort.

Erstellen und führen Sie Coroutinen sequentiell in Kotlin aus

Erstellen Sie das Paket com/coroutine im Ordner kotlin, das das Basispaket unserer Anwendung sein wird. Erstellen Sie eine Main.kt-Datei im Ordner coroutine und kopieren Sie den folgenden Code und fügen Sie ihn in die Datei ein.

package com.coroutine

import kotlinx.coroutines.async
import kotlinx.coroutines.delay
import kotlinx.coroutines.runBlocking

suspend fun executeProcedureOne(): Int{
    delay(3000L)
    println("procedure one executed")
    return 50;
}

suspend fun executeProcedureTwo(): Int{
    delay(1000L)
    println("procedure two executed")
    return 30;
}

fun main(): Unit = runBlocking {
    val value = async {
        executeProcedureOne()
    }
    value.await()
    val secondValue = async {
        executeProcedureTwo()
    }
    secondValue.await()
}

Im obigen Code haben wir zwei Methoden definiert, executeProcedureOne() und executeProcedureTwo(), die ausgesetzt werden können, um einige Hintergrundaufgaben auszuführen. Dies wird, wie oben gezeigt, mit dem Schlüsselwort suspend realisiert.

Beachten Sie, dass diese beiden Methoden ausgesetzt werden können, ohne den zugrunde liegenden Thread zu blockieren.

Wir haben der Hauptfunktion eine Funktion namens runBlocking zugewiesen. Die runBlocking-Funktion ist eine Builder-Funktion, die eine Coroutine erstellt, die im Haupt-Thread läuft und blockiert wird, bis die Coroutinen innerhalb der Funktion ihre Ausführung beendet haben.

Innerhalb der Funktion runBlocking haben wir zwei async-Funktionen erstellt, die die Methoden executeProcedureOne() bzw. executeProcedureTwo() aufrufen.

Die Funktion async ist ein Coroutine-Builder, der eine neue Coroutine erstellt und ein Deferred zurückgibt. Ein Deferred ist ein Future, das ein Versprechen darstellt, einen Wert zurückzugeben, und wir können await() verwenden, um den Wert abzurufen.

Beachten Sie, dass das Aufrufen von await() unmittelbar nach async dazu führt, dass die Coroutine ausgesetzt wird, da die innere Coroutine ausgeführt wird, und fortgesetzt wird, sobald sie beendet ist.

Der obige Code wird sequenziell ausgeführt, da die await()-Methoden nach jeder async-Funktion erzwingen, dass die Coroutine angehalten wird, bis sie abgeschlossen ist und zu den anderen Coroutinen wechseln kann.

Führen Sie den obigen Code aus und beachten Sie, dass executeProcedureOne() vor executeProcedureTwo() abgeschlossen wird, selbst wenn es am längsten verzögert wird. Die Ausgabe ist wie unten gezeigt.

procedure one executed
procedure two executed

Erstellen und Ausführen von Coroutinen gleichzeitig in Kotlin

Kommentieren Sie den vorherigen Code und kopieren Sie den folgenden Code und fügen Sie ihn direkt nach dem Kommentar in die Datei Main.kt ein.

suspend fun executeProcedureOne(): Int{
    delay(3000L)
    println("procedure one executed")
    return 50;
}

suspend fun executeProcedureTwo(): Int{
    delay(1000L)
    println("procedure two executed")
    return 30;
}

suspend fun executeProcedures() = coroutineScope{
    val firstValue = async {
        executeProcedureOne()
    }

    val secondValue = async {
        executeProcedureTwo()
    }

    firstValue.await()
    secondValue.await()
}

fun main(): Unit = runBlocking  {
    executeProcedures()
}

Wir haben das vorherige Beispiel so modifiziert, dass es gleichzeitig läuft, indem wir die async-Coroutine-Builder in eine andere suspendierbare Funktion verschoben haben, die einen coroutineScope und await() hat, nachdem die Funktionen ausgeführt wurden, um das Suspendieren einer Coroutine zu verhindern.

Der Unterschied zwischen coroutineScope und runBlocking besteht darin, dass coroutineScope angehalten wird und den zugrunde liegenden Thread freigibt, um mit der Ausführung anderer Aufgaben fortzufahren.

Führen Sie den obigen Code aus und beachten Sie, dass die Methode executeProcedureTwo() zuerst ausgeführt wird, da sie weniger Verzögerung hat als die Methode executeProcedureOne(). Die Ausgabe ist unten gezeigt.

procedure two executed
procedure one executed

Fazit

In diesem Tutorial haben wir gelernt, was Coroutinen sind und wie man sie sequenziell oder gleichzeitig mit Hilfe von async- await()-Funktionen ausführt. Wir haben auch einige gängige Konzepte im Zusammenhang mit Coroutinen kennengelernt, darunter asynchrone Programmierung, synchrone Programmierung, die Funktion runBlocking{} und die Funktion coroutineScope{}.