Running non-blocking coroutines within the main thread

Question

We've a special use case and I need help to find out, if we can solve our problem with Kotlin's coroutines or if we have to rely on CompletableFutures.

Basically, we write plugins for a server that is single threaded itself. This means, we can use different hooks to add logic and this logic always runs within the main thread that must not be blocked. In addition, when using the server's API, we must be within the main thread, because the given methods aren't thread safe.

To get this working with asynchronous code, we've used the server's scheduler to spawn a producer/consumer-system that runs asynchronous tasks in the background and synchronizes the results back to the server's main thread. The implementation shouldn't be that important, so here is just an example of how this looks like in practice:

// execute hook that runs when a user on the server runs a command
override fun execute(sender: CommandSender, args: Array<out String>) {
    // call comes from the main thread
    db.fetchBalance(sender.name)
        // fetchBalance runs asynchronous code without blocking
        // the current thread by utilizing a consumer/producer system
        .thenAccept {
            // the CompletableFuture is resolved after completion

            // here we are in the main thread again, so that we can access
            // server methods in a thread safe manner
            sender.sendMessage("Your balance: $it")
        }
}

Now my question is, if the above example can be replaced with Kotlin code that makes it more readable, like async/await in JavaScript. To remember, in JavaScript we can do this:

async function onBalanceRequest(client, name) {
  let balance = await db.fetchBalance(name);
  client.sendMessage("Your money: " + balance);
}

I've asked a similar question regarding to async/await some days ago, that led to a solution that could look like this:

private fun onBalanceRequest(sender: CommandSender) {
    // call comes from the main thread
    GlobalScope.launch {
        // here we are within a new thread
        val money = db.fetchBalance(sender.name).join()
        // here we are within the same thread, which is
        // not the main thread, so the code below isn't safe
        sender.sendMessage("Your balance: $money")
    }
}

As described in the comments, the problem is, that after "waiting for the future", the code runs in the coroutine's thread. So my question is, if we can achieve something like I've described with coroutines or if they were simply not made for this use case. I've read about the possibility to specify a thread for the spawned coroutine, but then this thread would be blocked, so that won't work.

If CompletableFutures are the only way to solve this problem, we will stick with them, but I wanted to give coroutines a try, since they look better to write and to handle than CompletableFutures.

Thanks

Answer 1

Try withContext function. Wrap your code in it and it will be executed in desired context.

For Example:

withContext(Dispatchers.Main) {
    //This will run in Main Thread
}

You can replace Dispatchers.Main with CoroutinesContext of your choice

Note: withContext function is "suspending" function and it must be executed only in Coroutine Scope

Answer 2

Executing Immediately

What if you do need it to execute immediately? For this, you can use

Dispatchers.Main.immediate

Executes coroutines immediately when it is already in the right context

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)

    launch(Dispatchers.Main.immediate) {
        log("A")
    }

    log("B")
}

Print

OUTPUT:
// A
// B