Of course I could add a level of indirection by using `Compl

Question

Of course I could add a level of indirection by using `CompletableDeferred` thank you very much for this suggestion Here s the final sample <https try kotlinlang org UserProjects dsu5vhgcr0ls2h0flirmp3pf9g ga94a9qaeq9e6v6s5bncbb75k3>

bj0 · Answer

they are useful tools depending on the situation from your example it looks like you are mixing 2 separate solutions together You can simplify it down to just

bj0 · Answer

``` val dispatcher = newSingleThreadContext dispatch val r1 = async dispatcher log Command 1 started delay 1200 log Command 1 finishing Command 1 result await log r1 val r2 = async dispatcher log Command 2 started delay 300 log Command 2 finishing Command 2 result await log r2 ```

r4zzz4k · Answer

In the real code there are multiple queues I want them to be separated and run in parallel So I actually have `fixedThreadPool` and multiple `actor`s

bj0 · Answer

yea `actor` is a good way to make sure stuff is executed serially if you have any suspension but usually you do the actual execution of the command inside the actor not just launch it in `async` and wait for it in the actor that doesn t guarantee serialization

r4zzz4k · Answer

Doesn t the ` await ` in the `actor` s body guarantees that the task is done before the next one is pulled in `async` coroutines that are sent to it are signalling response at their end after the command body is executed so from what I can see this should work `actor` awaits for the coroutine itself `post ` awaits for the `CompletableDeferred` which is completed at the very end of the coroutine

bj0 · Answer

it might be true for `LAZY` I ve never used that For normal `async ` it will not be true if your command has any type of suspend then other queue d `async ` s could start during that suspension

r4zzz4k · Answer

Oh I believe I understood your point According to the docs coroutines launched via `async` marked as `LAZY` are actually run after the ` await ` call or ` join ` ` start ` till that point they will just hang out there waiting to be started exactly what I need

bj0 · Answer

ah thats interesting though it might be a little confusing just reading the code

bj0 · Answer

you can get the same effect with something like ``` fun commandQueue context CoroutineContext = actor lt suspend gt Unit gt context = context log Command queue started for operation in channel operation log Command queue finished suspend fun lt T gt SendChannel lt suspend gt Unit gt post command gt T Deferred lt T gt val completable = CompletableDeferred lt T gt this send completable complete command return completable ```

bj0 · Answer

and you can `typealias` the function signature to make it look cleaner

r4zzz4k · Answer

In this case `actor` runs within separate context and so are commands Seems much cleaner I agree Will check that tomorrow as I m already on my way home thanks It s hard to switch to thinking in terms of neat concurrency of coroutines and channels after more than a year of C++ and dirty hand managed parallelism Thank you again for your help much appreciated

bj0 · Answer

yea it definitely takes some thought but once you start to get it it really is quite elegant good luck

bj0 · Answer

and yes by specifying the `newSingleThreadContext` as `CoroutineContext` to the `actor` the `actor` will only run on that thread which saves you from having to pass the dispatcher around to other places