Hey, Can I somehow have multiple threads using cor...

# multiplatform

[Deor]

Hey, Can I somehow have multiple threads using coroutines ? I know that in the documentation they say: The current version of kotlinx.coroutines, which can be used for iOS, supports usage only in a single thread. but supposedly there is a multithreded version

implementation ("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.9-native-mt"){
    version {
        strictly("1.3.9-native-mt")
    }
}

I can’t seem to make it work though and in the iOS app Everything is still done on a single background thread.

[Deor]

Thats more less the implementation:

suspend fun testSingleTaskOnMultipleBackgroundThread() = withContext(coroutineDispatcher) {
        val async1 = async(newSingleThreadContext("MyOwnThread")) { compute() }
        val async2 = async(newSingleThreadContext("MyOwnThread_no2")) { compute() }
        val async3 = async(newSingleThreadContext("MyOwnThread_no3")) { compute() }
        val async4 = async(newSingleThreadContext("MyOwnThread_no4")) { compute() }
        val async5 = async(newSingleThreadContext("MyOwnThread_no5")) { compute() }

        val total = async1.await() + async2.await() + async3.await() + async4.await() + async5.await()
        "four task on a background thread took $total adding them up"
    }

fun testSingleTaskOnMultipleBackgroundThread(onComplete: (String) -> Unit) {
        scope.launch {
            val report = mutableListOf("Android parallel report:")

            val duration = measureTime {
                report.add(threadPerformance.testSingleTaskOnMultipleBackgroundThread())
            }

            report.add("four task on a background thread took $duration in parallel")
            onComplete(report.joinToString(separator = "\n"))
        }
    }

[Deor]

Im primarly iOS so sorry if there is some obvious mistake Im making

[louiscad]

There's no multithreaded dispatcher in native for now

[Deor]

Ok can I use multiple dispatchers ?

[Deor]

Would that even make sense ?

[louiscad]

I think it could make sense if you see a real bottleneck because you're using only on background thread.

[Deor]

I think I kinda solved it.

[Deor]

suspend fun testAsyncMultithreading() = withContext(dispatcherProvider.background) {

        val async1 = async (dispatcherProvider.background) { compute() }

        val async2 = async (dispatcherProvider.background) { compute() }
        val async3 = async (dispatcherProvider.background) { compute() }
        val async4 = async (dispatcherProvider.background) { compute() }
        val async5 = async (dispatcherProvider.background) { compute() }

        val total = async1.await() + async2.await() + async3.await() + async4.await() + async5.await()
        println("four task on a background thread took $total adding them up")
    }

[Deor]

actual class DispatcherProvider {
    actual val main: CoroutineDispatcher = Dispatchers.Main
    actual val background: CoroutineDispatcher
    get() =  newSingleThreadContext("BackgroundThread")
}

[Deor]

It actually does stuff in parallel 😄

[louiscad]

You're never stopping the threads or closing the dispatchers?

[louiscad]

I think it'd be best to write your own async that finally closes the temporary dispatcher (or use the use extension if it exists for this type)

[Deor]

Thats a good point. I will look into that, Thanks

[louiscad]

Another possibility is to use a Worker