Coroutinen sind großartige Funktionen, die in der Kotlin-Sprache verfügbar sind. Ich habe es bereits versucht und es hat mir sehr gut gefallen.
Der Zweck dieses Artikels ist es, Ihnen das Verständnis von Corutins zu erleichtern. Seien Sie beim Lesen vorsichtig und Sie werden Erfolg haben.
Beginnen wir mit der offiziellen Definition von Corutin.
Coroutinen sind eine neue Methode zum Schreiben von asynchronem, nicht blockierendem Code.
Die erste Frage, die sich beim Lesen dieser Definition stellt, ist, wie sich Coroutinen von Flüssen unterscheiden.
Coroutinen sind leichte Strömungen. Ein leichtgewichtiger Thread bedeutet, dass er nicht an den nativen Thread gebunden ist. Daher muss der Kontext nicht zum Prozessor gewechselt werden, daher ist er schneller.
Was bedeutet es, "nicht an den nativen Thread angehängt" ?
Coroutinen kommen in vielen Programmiersprachen vor.
Grundsätzlich gibt es zwei Arten von Corutin:
- Verwenden des Stapels;
- nicht verwendeter Stapel;
Kotlin implementiert Coroutines ohne Stack. Dies bedeutet, dass Coroutines keinen eigenen Stack haben und daher nicht an den nativen Thread gebunden sind.
Sowohl Coroutinen als auch Streams sind Multitasking. Der Unterschied besteht jedoch darin, dass die Threads vom Betriebssystem und die Coroutinen von Benutzern gesteuert werden.
Jetzt können Sie den Auszug auf der offiziellen Kotlin-Website bewusst lesen und verstehen:
Coroutinen können in Form eines erleichterten Flusses dargestellt werden. Wie Threads können Coroutinen parallel arbeiten, aufeinander warten und kommunizieren. Der größte Unterschied besteht darin, dass Coroutinen sehr billig und fast kostenlos sind: Wir können sie zu Tausenden erstellen und zahlen nur sehr wenig für die Leistung. Streams sind teuer. Tausend Fäden können selbst für eine moderne Maschine ein ernstes Problem sein.
Mal sehen, wie man mit Coroutines arbeitet
Also, wie starte ich Coroutine (ähnlich wie beim Starten eines Threads)?
Es gibt zwei Funktionen zum Starten von Coroutinen:
Starten Sie {} vs async {} in Kotlin Coroutines
Der Unterschied besteht darin, dass launch{} nichts zurückgibt und async{} eine Deferred Instanz zurückgibt, die eine await() -Funktion hat, die das Ergebnis einer Coroutine zurückgibt, genau wie Future in Java, wo wir future.get() , um das Ergebnis zu erhalten .
Werfen wir einen Blick auf die Verwendung von launch {}
fun main(args: Array<String>) { println("Kotlin Start") launch(CommonPool) { delay(2000) println("Kotlin Inside") } println("Kotlin End") }
// The output will be // Kotlin Start // Kotlin End // Kotlin Inside
Dieser Code startet eine neue Coroutine in diesem Thread-Pool. In diesem Fall verwenden wir CommonPool , das ForkJoinPool.commonPool () verwendet . In einem Coroutine-basierten Programm sind noch Streams vorhanden, aber ein Thread kann viele Coroutinen ausführen, sodass nicht zu viele Threads erforderlich sind.
Versuchen wir eines:
fun main(args: Array<String>) { delay(2000) }
Wenn Sie dies direkt in der Hauptfunktion tun, erhalten Sie eine Fehlermeldung:
Interrupt-Funktionen können nur von Coroutine oder einer anderen Interrupt-Funktion aufgerufen werden.
Die Verzögerungsfunktion ist eine Interruptfunktion, daher können wir sie nur von einer Coroutine oder einer anderen Interruptfunktion aus aufrufen.
Lassen Sie uns das beheben:
fun main(args: Array<String>) { runBlocking { delay(2000) } }
Ein weiteres Beispiel:
suspend fun doWorkFor1Seconds(): String { delay(1000) return "doWorkFor1Seconds" }
suspend fun doWorkFor2Seconds(): String { delay(2000) return "doWorkFor2Seconds" }
// Serial execution private fun doWorksInSeries() { launch(CommonPool) { val one = doWorkFor1Seconds() val two = doWorkFor2Seconds() println("Kotlin One : " + one) println("Kotlin Two : " + two) } }
// The output is // Kotlin One : doWorkFor1Seconds // Kotlin Two : doWorkFor2Seconds
Schauen wir uns nun die Verwendung von async {} an
// Parallel execution private fun doWorksInParallel() { val one = async(CommonPool) { doWorkFor1Seconds() } val two = async(CommonPool) { doWorkFor2Seconds() } launch(CommonPool) { val combined = one.await() + "_" + two.await() println("Kotlin Combined : " + combined) } } // The output is // Kotlin Combined : doWorkFor1Seconds_doWorkFor2Seconds
Weil async{} wir async{} , können wir await() aufrufen, um das Ergebnis zu erhalten.
Viel Spaß beim Lernen;)