I've got a ktor server handling requests on something like

/user/{userId}

, how can I make sure requests pertaining to a specific

userId

are handled serially, but requests for different `userId`s can be handled in parallel? I don't want to use a single-threaded dispatcher per

userId

, I'd like to have a single shared pool that handles all the requests, just enforcing that requests for a given

userId

are handled in order. (I think this is more of a general coroutine question with ktor as an example than a ktor-specific question, but let me know if I'm wrong)

You don’t need any special dispatchers for this. You almost never need a custom dispatcher. One way to solve this is using actors: have an actor for each

userId

, store their channels in a map by the

userId

.

Thanks Zach...Wasn't thinking a custom dispatcher, just one per user ID...so is having a channel per user ID the right way to accomplish this?

Sorry, s/custom/dedicated/

Exactly why I want to avoid it 🙂

There are many ways to solve this, actors is just one of them.

I wanted just a single shared pool, just to be able to serialize the processing per user ID...I know the 'official' actor stuff is deprecated, but I the Channel solution you mentioned is basically an implementation of that, right?

Yea, pretty much. I meant “actor” in the abstract sense, so you can use the

actor

builder but that’s basically just a

Channel

+ a

launch

, nothing special really.

Will the channel-style make it more difficult to return the 'response'? I'm sure it can be done by passing a lambda in the task or something, but is there a nice idiom around getting the result of a task posted to a Channel?

Depending on how “pure” your actors are, there are a number of ways to model responses (google “actor model”). The simplest way with channels is to just include a

CompletableDeferred

in the message to the actor for the actor to send the response on.

I thought mutexes are generally a no-no with coroutines, or does kotlin have a coroutine-friendly mutex?

Yes, the coroutines library has

Mutex

and

Semaphore

.

Yeah I think your idea about passing the deferred is what occurred to me. But if there's a coroutine-friendly mutex then that could be even better--why wouldn't I be able to preserve order with that, though?

Well, I believe the standard Mutex will actually preserve first-in first-out order of

lock

calls, so you actually would preserve order. But I would verify that first.

Ok

Semaphore