👋 , I’d like to have a

suspending fun

that puts something in a queue and suspends until that “something” gets its turn and is finished being processed

Sounds like you just want a coroutine

Mutex

I think you are right, taking a look

The purpose of channels is to make a "pipeline" of async communication. Putting an item into a channel and then waiting for processing to complete isn't how they're intended to be used, which is why it's not working for you. A better pattern would be to have something put an item into Channel A, and when that item is done have it put an item into Channel B to be processed later. And ultimately when the whole pipeline is finished, data is posted back to the original caller through a callback or something like that. This would loosely be considered an "actor pattern" Alternatively, a

Flow

might be a better mechanism than raw channels, since by design the emitter will suspend until the collector has finished processing the item

somehow the idea of “mutex are no longer needed with coroutines” got into my head

The queue thing is possible with a

CompleteableJob

in the item to signal when done but it’s easy to mess up error situations and you lose natural structured concurrency

I’ll explore both approaches

mutex

and

flows

and report back, thanks! for the help

One approach to this would be to use the

suspendCoroutine

function e.g. in pseudocode:

fun queuedProcess(someParam: Param) = suspendCoroutine { continuation -> 
    addToQueue(param, continuation)
    ensureQueueIsRunning()
}

...and elsewhere, the queue processing calls

queueItem.continuation(result

)

You could possibly have a simple for loop of suspend functions and run them sequentially by your need.

The

suspendCoroutine

route works, but it might be easier and make the intent clearer to use a CompletableDeferred, which would effectively do the same thing