RunBlocking in Kotlin Coroutine
Tags: kotlin, coroutine, android
Published: 2023-02-28 02:30:39


In previous post, we have gone through most of the key concepts and methods in Coroutine:

> Kotlin Coroutines Table Content  
>   
> 1, [Introduction to Coroutine in Kotlin](https://needone.app/introduction-to-coroutine-in-kotlin/)  
> 2, [Non-blocking in Kotlin Coroutines](https://needone.app/non-blocking-in-kotlin-coroutines/)  
> 3, [Start and Suspend a Coroutine in Kotlin](https://needone.app/start-and-suspend-a-coroutine-in-kotlin/needone.app/start-and-suspend-a-coroutine-in-kotlin/)

However, we haven't talked about `runBlocking` yet, which is a function provided by the `kotlinx.coroutines` library in Kotlin. It is used to start a new coroutine that runs **synchronously** on the current thread and blocks the thread until the coroutine completes.

`runBlocking` is typically used to start a coroutine from a non-coroutine context, such as a main function, a unit test, or a Java method. It allows you to start a coroutine and wait for it to complete without having to manually manage the lifecycle of the coroutine.

Here's an example of how you might use `runBlocking` to start a coroutine and wait for it to complete:

```kotlin
import kotlinx.coroutines.*

fun main() {
    runBlocking {
        val result = async {
            delay(1000)
            "Hello, World!"
        }
        println(result.await())
    }
}
```

In this example, the `runBlocking` function starts a new coroutine that runs on the current thread (the main thread in this case). Inside the coroutine, we use the `async` function to start another coroutine that sleeps for one second and then returns a string. The `await()` function is used to wait for the result of the async coroutine and the result is printed out after 1 sec.

It's important to note that `runBlocking` is a blocking function, so it should be used with caution. It can be useful for small test cases, but for longer-running coroutines it is recommended to use the `launch` or `async` functions and manage the lifecycle of the coroutines manually, in order to not block the main thread.

## RunBlocking for Unit testing 

`runBlocking` often is used in unit tests to start a coroutine and wait for it to complete. This allows you to test coroutines in a synchronous manner, making it easier to write tests and assert on the results.

Here's an example of how you might use `runBlocking` in a JUnit test:

```kotlin
import kotlinx.coroutines.*
import org.junit.Test

class MyTests {
    @Test
    fun testCoroutine() = runBlocking {
        val result = async {
            delay(1000)
            "Hello, World!"
        }
        assertEquals("Hello, World!", result.await())
    }
}

```

In this example, we use the `runBlocking` function to start a new coroutine in the context of the test method. The coroutine sleeps for 1 sec and returns a string, which is then asserted in the test.

Using `runBlocking` in unit tests can make it easier to write tests and assert on the results of coroutines, but it's important to be aware that it makes the test synchronous, so it will block the current thread until the coroutine completes. Also, it's important to make sure that your coroutines are properly isolated from other parts of the system, by using Dispatchers.Unconfined or test dispatchers, to avoid unexpected results in your test.

Ref: https://needone.app/runblocking-in-kotlin/