Is there a common pattern for starting a coroutine...

# coroutines

[Niklas Gürtler]

Is there a common pattern for starting a coroutine, when you only ever want one or zero instances of it running? Something like

class MyActivity {
    var coroJob : Job? = null
    val coroScope = MainScope()
  
    // Start my coroutine, may be called from any thread
    fun startCoro () {
        // coroJob should only be accessed from main thread
        coroutineScope.launch (Dispatchers.Main) {
            if (coroJob == null) {
                coroJob = coroutineScope.launch (<http://Dispatchers.IO|Dispatchers.IO>) {
                    // Do the actual work here ...

                    withContext(Dispatchers.Main) {
                        coroJob = null
                    }
                }
            }
        }
    }  
}

But reducing the boiler plate?

[tseisel]

You may use an actor coroutine:

val triggerChannel: SendChannel<Unit> = scope.actor<Unit> {
  for (unit in channel) {
    // Do stuff
  }
}

// Send params via the channel whenever you want to perform work.
triggerChannel.offer(Unit)

Using an actor you are guaranteed that only one instance of your task is running at the time.
You may also tweak the actor's capacity to enqueue (or discard) work requests that were sent before previous work finished.
Don't forget to close the channel when done with it!

[Niklas Gürtler]

Ah nice idea! So the actor is permanently running but blocked as long as nothing is in queue, right?

[tseisel]

Yes, the for loop suspends until something is pushed to the channel. It won't consume a thread while waiting, so it is completely safe to use Dispatchers.Main (unless you are directly calling blocking IO functions in the actor's body, of course).

[Niklas Gürtler]

Ah right. I am doing IO so I'd use the IO dispatcher, and I need some post processing on the main thread. So I'm trying:

private val actor1 = (coroutineScope+<http://Dispatchers.IO|Dispatchers.IO>).actor<Unit> (capacity = Channel.CONFLATED) {
    for (u in channel) {
        val result = ... do stuff ...
        actor2.offer (result)
    }
}

private val actor2 = (coroutineScope+Dispatchers.Main).actor<Result> (capacity = Channel.CONFLATED) {
    for (t in channel)
        ... post process t ...
}


fun start () {
    actor1.offer (Unit);
}

[tseisel]

Yes, that's the idea. I suggest that you use actor2.send(result) instead of actor2.offer(result) if you absolutely need each task to run post-processing.
The key difference is that offer is not suspending and will drop the result if actor2 is busy, while send will suspend until actor2 is ready.

[Niklas Gürtler]

Good point, yes send is indeed more suitable. Thanks!

[gildor]

I wouldn't use actor for that, it will change api soon and just write simple abstraction on top of Job