<@U8X1UM66N> example with single thread context you proposed ``` fun main(args: Array&lt;String&gt;)...

# coroutines

[stepango]

@Jonathan example with single thread context you proposed

fun main(args: Array<String>) {
    val context = newSingleThreadContext("test")
    launch(context) {
        withContext(context) {
            CompletableFuture.runAsync {
                print("Hello")
            }.await()
        }
    }
}

suspend fun <T> CompletableFuture<T>.await() = suspendCoroutine<T> { cont ->
    cont.resume(join())
}

Not working😮

[Jonathan]

You have to make the main thread waiting for the result

[stepango]

Yeah man I know that's why i was telling you it will not work.

[Jonathan]

fun main(args: Array<String>) = runBlocking {
    val context = newSingleThreadContext("test")
    launch(context) {
        withContext(context) {
            CompletableFuture.runAsync {
                print("Hello")
            }.await()
        }
    }.join()
}

[Jonathan]

BTW there is already a better implementation of CompletableFuture.await in kotlinx.coroutines-jdk8

[Jonathan]

Or if you don't want to join you can use parent-child relation:

fun main(args: Array<String>) = runBlocking {
    val context = newSingleThreadContext("test")
    launch(coroutineContext + context) {
        withContext(context) {
            CompletableFuture.runAsync {
                print("Hello")
            }.await()
        }
    }
}

[Jonathan]

And you should close the thread context too.

[stepango]

Oh man, your code examples just avoiding problem that I trying to figure out how to solve properly😊

[Jonathan]

Sorry, I obviously don't understand what you want to achieve.

[ilya.gorbunov]

@stepango Then it's great, if you don't have a problem, you don't have to solve it.
Seriously, `runBlocking`+`withContext` seems to be the way to go in your situation, judging on your original code example (handleAction)

[stepango]

@ilya.gorbunov But I don't have an option to wrap execution in runBlocking I just need right context to this construction to make launch + withContext run synchronously, thats it😊 So far Unconfined works as I expect, but is there any other context that would be more suitable for this?

[Jonathan]

@stepango Why cannot you use runBlocking? This function can be called from anywhere and anything can be called in the lambda. And even if runBlocking should generally be avoided, it is a first class choice when it comes to testing.

[stepango]

@Jonathan believe me it does not matter

fun test(){
        smth(coroutineContext) // Unit
        //^not suspend function i can't change contains launch + withContext
}

I want to change coroutine context in the way that will make smth function to run synchronously

[stepango]

runBlocking will not help me here

[Jonathan]

fun test() {
	newSingleThreadContext("test context").use { context ->	
		runBlocking(context) {
			smth(context) // Unit
			// no need to suspend
			// no need to change launch + withContext
		}
	}
}

[Jonathan]

Sorry, I still don't understand why runBlocking doesn't help.