How to make Kotlin's LifecycleScope has sequential behaviour as Java's Executors.newSingleThreadExecutor?

Question

In Java Android, to achieve sequential behavior without blocking main thread, this is the code I am using.

Java Android

private static final ExecutorService executor = Executors.newSingleThreadExecutor();

executor.execute(() -> task0());
executor.execute(() -> task1());
executor.execute(() -> task2());

The above code, will always execute in the exact order of task0, task1 and task2 functions regardless what is happening inside the functions.

I am impressed by the life cycle aware feature, offered by Kotlin's LifecycleScope. I try to write the code in the following Kotlin's LifecycleScope form.

Kotlin Android

val dispatcherForCalendar = Executors.newSingleThreadExecutor().asCoroutineDispatcher()

lifecycleScope.launch(dispatcherForCalendar) {
    task0()
}
lifecycleScope.launch(dispatcherForCalendar) {
    task1()
}
lifecycleScope.launch(dispatcherForCalendar) {
    task2()
}

---

The above code will executed in the exact order of task0, task1 and task2 functions, except when delay is performed in the functions.

1. In reality, I will not insert delay code explicitly in task functions. In such a case, can Android system still perform delay operation implicitly?
2. How I can achieve sequential behavior, same as my Java code Executors.newSingleThreadExecutor?

Thank you.

Answer 1

Regarding 1):

The coroutines may yield the thread back to the dispatcher at any suspend function call, not just at delay() calls.

Regarding 2):

My answer here shows how you can build a sequential task queue using a Channel. You could modify the class to allow a CoroutineScope to be injected in the constructor, so lifecycleScope could be passed in when using it in an Activity or Fragment. Something like this:

class JobQueue(
    private val scope: CoroutineScope,
    private val defaultContext: CoroutineContext = Dispatchers.Main
) {
    private val queue = Channel<Job>(Channel.UNLIMITED)

    init { 
        scope.launch(Dispatchers.Default) {
            for (job in queue) job.join()
        }
    }

    fun submit(
        context: CoroutineContext = defaultContext,
        block: suspend CoroutineScope.() -> Unit
    ) {
        synchronized { 
            val job = scope.launch(context, CoroutineStart.LAZY, block)
            queue.trySend(job)
        }
    }
}

If these were blocking jobs, you might for example pass Dispatchers.IO as the defaultContext for running the jobs.