Hello everyone. Is it possible to use kotlinx/coroutine with background thread in the future ? I fou...

# kotlin-native

[yuya_horita]

Hello everyone.
Is it possible to use kotlinx/coroutine with background thread in the future ?
I found the convesation in <https://github.com/Kotlin/kotlinx.coroutines/issues/462>, but I can’t get it in detail.
(Only single thread will be supported and improved ?)

[Tobi]

I also have a hard time understanding this.

For example when I look at the ktor mpp example:
https://github.com/ktorio/ktor-samples/blob/master/mpp/client-mpp/src/commonMain/kotlin/io/ktor/samples/mpp/client/Api.kt

We can launch a coroutine from the main thread to execute a http request, but dispatching one using <http://Dispatchers.IO|Dispatchers.IO> and waiting for the result using async is not possible?

[yuya_horita]

As far as I know, No.

[yuya_horita]

Kotlin/Native’s immutability is special. Unless you freeze() an object, you can’t share the object among several threads even if it is declared as val.

[yuya_horita]

final class Default: Kotlinx_coroutines_core_nativeCoroutineDispatcher {
    override func dispatch(context: KotlinCoroutineContext, block: Kotlinx_coroutines_core_nativeRunnable) {
        DispatchQueue.global(qos: .default).async { block.run() }
    }
}

I’m writing codes like this. It seems that when I access block, this code crashes.

[yuya_horita]

But, it works properly with DispatchQueue.main instead of global(qos: .default)

[yuya_horita]

maybe, crashed caused by (`https://github.com/JetBrains/kotlin-native/blob/master/runtime/src/main/cpp/Memory.cpp#L426`)

[Konstantin Petrukhnov]

global(qos: .default) could give different threads. DispatchQueue.main is always UI thread.

[Konstantin Petrukhnov]

What is subthread? thread that started by other thread?

[yuya_horita]

sorry, I mean background thread

[Landerl Young]

As far as I know. Currently, NO. You can not use background thread in Kotlin/Native Coroutines, It is single threaded now.

But according to @elizarov , they are working on it. Hope it be implemented.

[Tobi]

But that would mean that the ktor multiplatform example would execute the http call on the main thread on iOS 🤔
How I understand it is that you can use a background thread, but you can’t have a dispatcher back to the main thread.

[elizarov]

But with coroutines you don’t block the main thread when you execute the http call! Coroutines enable concurrency without multithreading.

[yuya_horita]

@elizarov
Yes, Http call with coroutines does not block main thread. But, in iOS, main queue (which manages main thread) is a serial queue.
This means one processing will be done after other processing which is queued previously have done.

This is a problem in case of these.
- calling many http requesting at once. (should be done concurrently.)
- calling http request after heavy processing like image processing.

[yuya_horita]

this is an example

[yuya_horita]

DispatchQueue.main.async {
    print("1")
    sleep(10)  // this is a heavy processing
    print("2")
    sleep(10) 
}


httpCall()        // This is a function showing `hello` after receiving response. Dispatched to main queue with coroutines
print("I'm here")

[yuya_horita]

async processing does not block main thread. So the output is like below.

I'm here
1
2
hello

[yuya_horita]

hello will be printed after 20seconds later. This is a problem.

[yuya_horita]

Background thread with global concurrent queue can solve this.

[yuya_horita]

This is an old thread, so I’ll write it in channel 🙏