Question about the <limitedParallelism> API. Is the following assumption correct? ```val singleDisp...

# coroutines

[Remy Benza]

Question about the limitedParallelism API. Is the following assumption correct?

val singleDispatcher = Dispatchers.IO.limitedParallism(1)

suspend fun codeBlockA() = withContext(singleDispatcher) { .. }

suspend fun codeBlockB() = withContext(singleDispatcher) { .. }

Never in time will code inside functions codeBlockA and codeBlockB be running at the same time. Irrespective of when / how often they are invoked and/or what parent coroutine there are launched from. Correct?

[Remy Benza]

so if codeBlockB is invoked while codeBlockA is still executing, the singleDispatcher will then 'queue' the coroutine until singleDispatcher is 'free' for execution?

Similar to thread confinement?

[Remy Benza]

With the difference that the 'next' coroutine could be executed on a different thread. But only when the previous one is finished?

[Joffrey]

That's how I understood it as well, yes

[Remy Benza]

thnx

[Remy Benza]

@Joffrey to follow up, what if there is a dispatcher switch inside one of the blocks?


e.g.

val singleDispatcher = Dispatchers.IO.limitedParallism(1)

fun myFunction() {
  scope.lauch(singleDispatcher) {
    val a = someOtherFunction() = withContext(<http://Dispatcher.IO|Dispatcher.IO>) { ... }

  }
}

[Remy Benza]

what happens then? does this code still guarantees that it's run on singleDispatcher?

[Joffrey]

Not 100% sure, but I believe the way it should behave is that the stuff running inside the withContext(<http://Dispatchers.IO|Dispatchers.IO>) would not be subject to the parallelism limit

[Remy Benza]

so I should also dispatch that code with singleDispatcher to prevent concurrency?

[Remy Benza]

Maybe @louiscad knows, the coroutine guru? 😄

[louiscad]

The code running in the dispatcher might suspend, and then, you still have concurrency that you need to take into account. The blocking portions will never execute concurrently though.

If you need to prevent concurrency across coroutines (and across suspension points), Mutex is the API you're looking for.

[Remy Benza]

so calling a second suspending function inside a myFunction() and also preventing concurrency is not possible with .limitedParallism API?

[Remy Benza]

even when I dispatch that code onto the same singleDispatcher?

[louiscad]

limitedParallelism is only an alternative to single threaded dispatchers. It's not a replacement for Mutexes.