Hello, why does it not print 1 2 3 ``` runBlockin...

# coroutines

[Paulius Ruminas]

Hello,

why does it not print 1 2 3

runBlocking {
            val producer = async {
                produce {
                    send(1)
                    send(2)
                    send(3)
                }
            }

            launch {
                producer.await().consumeEach { println(it) }
            }
        }

[gildor]

Because async never returns, just suspend untill all child coroutines are finished (which doesn’t happen in your case).
Actual problem that you never call consumeEach, because await() never return

[gildor]

To fix it, just unwrap produce

[gildor]

What is you real use case for this?

[Paulius Ruminas]

If i unwrap produce then it will not return a channel.

[Paulius Ruminas]

or do you mean remove async?

[gildor]

What do you mean?

[gildor]

yes, remove async

[gildor]

This is how scopes of coroutine builder works, they allow to start child coroutines, but never return until child is finished to prevent coroutine leaking

[gildor]

What you actually trying to do can be achived by launching produce without relation to async using GlobalScope. but it’s not a recommended way to work with scopes, this is why I’m asking about your use case

[Paulius Ruminas]

class A {

    suspend fun startGeneratingData() = coroutineScope {
        produce {
            send(1)
            send(2)
            send(3)
        }
    }
}

class B {

    suspend fun startGeneratingData() = coroutineScope {
        produce {
            send(1)
            send(2)
            send(3)
        }
    }
}

enum class GeneratorType {
    A, B
}

class C(
    private val a: A,
    private val b: B,
    override val coroutineContext: CoroutineContext
): CoroutineScope {

    private val actions = Channel<Action>()

    private sealed class Action {
        data class Start(val type: GeneratorType): Action()
        object Stop: Action()
    }

    init {
        launch {
            val job = coroutineContext + Job()

            actions.consumeEach { action ->
                when (action) {
                    is Action.Start -> launch(job) {
                        when (action.type) {
                            GeneratorType.A -> a.startGeneratingData()
                            GeneratorType.B -> b.startGeneratingData()
                        }
                    }
                    Action.Stop -> job.cancelChildren()
                }
            }
        }
    }

    suspend fun start(type: GeneratorType) {
        actions.send(Action.Start(type))
    }

    suspend fun stop(type: GeneratorType) {
        actions.send(Action.Stop)
    }
}

fun main() = runBlocking {
    val c = C(A(), B(), Dispatchers.Unconfined)

    c.start(GeneratorType.A)
}

[Paulius Ruminas]

I have two types of producers (2 different physical devices that could connected and disconnected)

[Paulius Ruminas]

I want to have a class that would handle both of them

[gildor]

I didn’t check all code, it’s pretty big, but this part is wrong by definition, check documentation of coroutineScope function

suspend fun startGeneratingData() = coroutineScope {
        produce {
            send(1)
            send(2)
            send(3)
        }
    }

[gildor]

Instead of using coroutineScope which never return if there are any child coroutine in progress, pass CoroutineScope instance to this function or make startGeneratingData() extension of coroutine scope

[Paulius Ruminas]

Ok i understand know, coroutineScope will not return untill all children are in progress. Thank you for you help!

[gildor]

Action.Stop -> job.cancelChildren() as I understand you can replace it with cancel() on this channel

[Paulius Ruminas]

I did it to avoid nullable mutable variable, since one needs to track which producer is active. I did not add it to the example snippet but only one producer can be active so job.cancelChildren happens on any new action in production code.

var activeProducer: ReceiveChannel<Int>?

Is there any side effects of doing it with a job instead of a mutable variable?

[gildor]

no side effects, just looks a bit overcomplicated comparing with nullable job

[gildor]

also with nullable job you at least can check is any job started or not

[Paulius Ruminas]

I was thinking why is it named coroutineScope? It's a noun so from the name i would think that it is factory method to create a coroutine scope not to launch multiple coroutines with the same job. launch is a verb so one assumes that it will run computations but with coroutineScope i do not think it is that obvious.

[gildor]

i would think that it is factory method to create a coroutine scope

Yes, and it creates coroutine scope

[gildor]

but I tend to agree, it usual source of misconception of this function, but documentation fortunately is pretty clear

[Paulius Ruminas]

From the call site you can not tell if it creates a coroutine scope (since there is no return CoroutineScope) that is why it is confusing atleast for me.

[gildor]

But shouldn’t create coroutine scope, it provides block with a new coroutine scope