A modern programming language that makes developers happier.

kotlinlang

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 ?)

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?

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`.

```
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.

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

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

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

What is subthread? thread that started by other thread?

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 <@U2E974ELT> , they are working on it. Hope it be implemented.

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

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

<@U2E974ELT>
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.

```
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")
```

async processing does not block main thread. So the output is like below.
```
I'm here
1
2
hello
```

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

Background thread with global concurrent queue can solve this.

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