Kotlin runBlocking: Überbrückung der Nicht-Coroutine-Welt mit Coroutine-Code

Die Kotlin-Funktion runBlocking() ist eine Suspend-Funktion, die den main-Thread blockiert. Es hilft, eine Brücke zwischen dem synchronen und dem asynchronen Code zu schaffen.

In diesem Artikel lernen wir Kotlin runBlocking() und seine Verwendung in verschiedenen Szenarien kennen.

die runBlocking-Funktion in Kotlin

Sie haben vielleicht schon von der delay()-Funktion in Kotlin gehört. Die Funktion delay() hält die Coroutine an und verzögert sie um eine bestimmte Zeit.

Es blockiert jedoch nicht den gesamten Thread. Das bedeutet, dass wir bei Verwendung der Funktion delay() immer noch andere Operationen ausführen können, z. B. Änderungen in der Benutzeroberfläche vornehmen.

Andererseits blockiert die Funktion runBlocking() einen ganzen Thread bis zu seinem Abschluss. Daher führt der Compiler nichts anderes aus, bis der Thread mit dem runBlocking()-Code abgeschlossen ist.

Der neue Thread, der von der Kotlin-Funktion runBlocking() gestartet wird, wird vom main-Thread aus gestartet.

Um dies zu verstehen, schauen wir uns zwei Beispielcodes an. Im ersten Code verwenden wir die Funktion delay() in GlobalScope.launch(). Und im zweiten Beispiel verwenden wir es in der Kotlin-Funktion runBlocking().

Verwenden Sie delay() in GlobalScope.launch()

package com.example.mycoroutines

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import android.widget.Toast
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch

class MainActivity : AppCompatActivity() {
    val TAG:String="This is Main Activity"
    override fun myFunc(savedInstanceState: Bundle?) {
        super.myFunc(savedInstanceState)
        setContentView(R.layout.activity_main)
        GlobalScope.launch(Dispatchers.Main) {
            delay(5000)
            Log.d(TAG,"Global Scope")
            Toast.makeText(applicationContext,"Thread executed in global scope",Toast.LENGTH_SHORT).show()
        }
        Log.d(TAG,"Not Global Scope")
        Toast.makeText(applicationContext,"Thread executed is not in Global Scope",Toast.LENGTH_SHORT).show()
    }
}

Wenn Sie einen solchen Code im Android Studio ausführen, wird das Tag "Not Global Scope" ausgeführt. Die Nachricht des Tags "Global Scope" wird dann mit einer Verzögerung von 5 Sekunden ausgeführt.

Das bedeutet, dass es nur eine Verzögerung gibt, aber Operationen werden trotzdem ausgeführt. Daher wird der Thread nicht vollständig blockiert.

Verwenden Sie delay() in Kotlin runBlocking()

Wie bereits gesehen, wird nicht der gesamte Thread blockiert, wenn wir die Funktion delay() in GlobalScope.launch() verwenden.

Aber wenn wir es in Kotlin runBlocking verwenden, wird der Thread blockiert, bis alle Funktionen aus dem runBlocking-Code ausgeführt sind. Hier ist ein Beispiel, um dasselbe zu demonstrieren.

package com.example.mycoroutines

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import android.widget.Toast
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch

class MainActivity : AppCompatActivity() {
    val TAG:String="This is Main Activity"
    override fun myFunc(savedInstanceState: Bundle?) {
        super.myFunc(savedInstanceState)
        setContentView(R.layout.activity_main)
        Log.d(TAG, "Prior using run blocking")
            runBlocking 
              {
              Log.d(TAG,"Entered run-blocking")
              delay(3000)

              Log.d(TAG,"Run-blocking started")
              Log.d(TAG,"Run-blocking ended")
            }
        Log.d(TAG,"Post using run blocking")
    }
}

Wenn wir diesen Code verwenden, wird das Tag "Post using run blocking" zuletzt ausgeführt. Der Grund dafür ist, dass alle Ausführungen angehalten werden, bis der gesamte runBlocking-Code ausgeführt ist.