async lazy val pattern causes infinite suspend

Hi, I’ve just noticed that using new structural coroutines, the code which uses async(start = CoroutineStart.LAZY) { } causes infinite suspend.

As I understand these async(start = CoroutineStart.LAZY) is now treated as a children of TestView object and new coroutine engine waits until these async completes. Shouldn’t LAZY async coroutines be excluded from a wait list if they are not running? Maybe there are more proper way to implement lazy async val?

test example:

class TestView(override val coroutineContext: CoroutineContext) : CoroutineScope {
    val title: Deferred<String> = async(start = CoroutineStart.LAZY) { "demo" }
    val description: Deferred<String> = async(start = CoroutineStart.LAZY) { "desc" }
}

class TestClass {
    suspend fun getView(id: Int): TestView = coroutineScope { TestView(coroutineContext = coroutineContext) }
}

runBlocking {
  val view = TestClass().getView(123)
}

[chrisjenx]

Not sure why this is closed, this shouldn’t break randomly depending on how you write the async.

This suspends forever:

withContext(Dispatchers.IO) {
 async(start= LAZY) {}
}

This works fine:

GlobalScope.async(Dispatchers.IO, start= LAZY) { }

There should not be magic like this - esp considering this has been a problem for nearly two years.

[LouisCAD]

My current code is the following, does it look right to you?

private class SuspendLazySuspendingImpl<out T>(
    private val dispatcher: CoroutineDispatcher = Dispatchers.Default,
    initializer: suspend () -> T
) {
    private val lazyValue = lazy { GlobalScope.async(dispatcher) { initializer() }}
    suspend operator fun invoke(): T = with(lazyValue) {
        if (isInitialized()) value else withContext(dispatcher) { value }
    }.await()
}