A modern programming language that makes developers happier.

kotlinlang

How can I block while a coroutine is running? My use case is that I'm confining operations to one thread in a class which has shared mutable state so I have to use a single threaded coroutine dispatcher, but I also want to provide a synchronous interface for my users. How can I do this?

you can run all the suspend functions through a Mutex() that only allows one suspend function at a time :thinking_face:. But not sure if that would be the ideal solution for your usecase.

no it is not, i tried that but it is extremely slow

i have presistent data structures so reads are not confined (no coroutines)

writes are confined, but I only want to return from a mutating method when the mutation is complete

so you have

```suspend fun doWrite(input): Result {}```
and
```fun doWriteSync(input): Result {
    scope.launch{ doWrite(input) }
}```

And the suspend function works fine and returns when it returns, but you want the synchronous blocking one to return only when the suspend one is done?

runBlocking  available only on JVM and Native, but not on JS (because there is just no proper way to block thread), so it’s not available there

If you don't have a JS target, you can do expect/actual for  `runBlocking`.

I refactored my methods which use coroutines to not return a value

and I have getters which aren't using coroutines but safe to call, because they are using persistent data structures

do any of you have a better idea for this?

If I understand correctly, you want to execute a sequence of write operations on some mutable shared state.
Have you tried the `Channel` api. It behaves as a blockingQueue basically, where you can send message/operations in a queue manner.

no, as it turns out what I need is `@Synchronized` :smile: