Second coroutine is never executed

user_7857150 0
Viewed 61

I have two coroutines inside another one, it's supposed that both inner coroutines are going to execute asynchronously, but this doesn't happened. The second one waits until the first finish. This is my code:

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.launch

class MainActivity : AppCompatActivity() {
     var flag = false
     override fun onCreate(savedInstanceState: Bundle?) {
          super.onCreate(savedInstanceState)
          setContentView(R.layout.activity_main)

          runBlocking {
                launch {
                    printOne()
                }
                launch {
                    printTwo()
                }
          }
    }

    suspend fun printOne() {
         while (flag == false)
             Log.e("log", "111111")
    }

    suspend fun printTwo() {
         Log.e("log", "222222")
         Log.e("log", "222222")
         Log.e("log", "222222")
         Log.e("log", "222222")
         flag = true
   }
}

I assumed that the code inside the first launch{} would execute in a thread separately from the code in the second launch{} as well as any other corutine. But it keeps looping for ever inside the first launch{}

kotlin-coroutines kotlin
4 Answers

Is Log.e a suspend function? If not, then your first coroutine never calls another suspend function, and never explicitly yields, so it never gives other coroutines a chance to run on the same thread.

The call to runBlocking is using a default dispatcher that uses only one thread, so there's no thread available to run the second coroutine.

You could fix this by explicitly yielding after every loop iteration:

suspend fun printOne() {
    while (flag == false) {
        Log.e("log", "111111")
        yield() // <-- give other coroutines a turn
    }
}

If you try to fix the problem by using a different dispatcher (like runBlocking(Dispatchers.IO)), you may notice another problem...

The flag variable is not volatile. Changes to the variable made by a coroutine running in one thread might not be seen by cooroutines in a different thread for a long time, if ever. You could fix this by annotating the property as volatile:

@Volatile
var flag = false
user_6118190

Coroutines are not threads. You can set them to run in different threads if you want, using Dispatchers, but if not, you have to let execution time for other coroutines in the same thread with yield() or delay(Long).

user_198012970

You are using runBlocking. Replace it for lifecycleScope.launch.

The Android library for activities/fragment added a coroutine launcher tied to the lifecycle.

user_40175010

I think you can get your answer with this simple example

suspend fun printOne() {
    println( "111111")
        delay(200)
    println( "111111")
        delay(200)
    println( "111111")
        delay(200)
    println( "111111")
        delay(200)
    println( "111111")
        delay(200)
    println( "111111")
        delay(200)
    println( "111111")
        delay(200)
    println( "111111")
        delay(200)
}

suspend fun printTwo() {
    println( "222222")
        delay(100)
    println( "222222")
        delay(100)
    println( "222222")
        delay(100)
    println( "222222")
        delay(100)
}
user_172933970
Related