Multiple state machines and coroutines

[Lukasmp3]

From the documentation I understand that it is recommended to use KStateMachine in the single thread. I have an application in which I need to create multiple StateMachines. Imagine I have a following GraphQL endpoint

suspend fun changeOrderState(orderId: Int, event: Event) {
  val order = orderDao.findById(orderId)
  val scope = CoroutineScope(Dispatchers.Default.limitedParallelism(1)) // Is this correct?
  val stateMachine = createStateMachine(scope) {
    ...
    setInitialState(order.currentState)
  }
  stateMachine.processEvent(event) // does something with the order for a few seconds and saves it with orderDao
  stateMachine.destroy()
}

But I'm not sure if I this is correct approach. I need to have multiple State Machines running concurrently and not to block each other. When I tried to run multiple concurrent request I was getting IllegalStateException(Paid parent is not set) (where Paid is the state name) which I never seen when running sequentially so I though concurrency might be the cause.

[nsk90]

Hi, no limitedParallelism(1) is not correct. It only limits the amount of threads that are used by the scope, but it does not guarantee that it will always be exactly the same thread for each coroutine launched in this scope. So multiple threads can touch StateMachine's variables (not concurrently, but one by one). Such multithreading behaviour requires "memory barriers" to force those threads share variable changes which they have made between each other. Otherwise they can work with their own state of a variable that can possibly be outdated. On JVM such a "memory barriers" are set by the volatile keyword.

You can find correct scope configuration samples in a docs https://kstatemachine.github.io/kstatemachine/#multithreading-and-concurrency

[Lukasmp3]

Thanks for explanation but I guess CoroutineScope(newSingleThreadContext("single thread")) is not appropriate here because it blocks the thread and therefore I cannot have multiple state machines (in different coroutine) processing events concurrently, am I right?

[nsk90]

No, newSingleThreadContext function just creates a thread and a CoroutineScope uses it to run coroutines inside. So it blocks calling thread only for a short time (means it is non-blocking)
Each call to newSingleThreadContext starts new thread. This is resource allocation so don't forget to close it when you are done with it's machine.

State machines that are attached to different threads such way, will run concurrently (to each other). As I understood that is what you need.

Keep in mind that thread allocation is not so cheap as coroutine startup. And if your method is called frequently you can get an error from OS that too many threads were created (about 200 I suppose). So thread pool should be preferred (but one machine must be processed only by its special thread during all it's lifetime).