If I am writing a piece of code for kotlin multiplatform I t

Question

If I am writing a piece of code for kotlin multiplatform I tried to improve the following code to get rid of the GlobalScope launch ```class ChannelWorker private val requestChannel = Channel lt FooRequest gt private val responseChannel = Channel lt FooResult gt init GlobalScope launch while true val receive = requestChannel receive val resp = fetchStuff receive id responseChannel send FooResult resp private suspend fun fetchStuff id String Int delay 1000 return id toInt ``` version 2 ```class ChannelWorker private val requestChannel = Channel lt FooRequest gt private val responseChannel = Channel lt FooResult gt init CoroutineScope EmptyCoroutineContext launch for message in requestChannel val resp = fetchStuff message id responseChannel send FooResult resp private suspend fun fetchStuff id String Int delay 1000 return id toInt ``` still I am creating a coroutine in a init block is that really a good thing how will the lifecycle of that coroutine be managed What happens when an object of ChannelWorker goes out of scope how would I stop the channel receiver coroutine Or is it cleaner if ChannelWorker has start and stop methods

ephemient · Answer

creating a CoroutineScope like 2 is a bad idea your coroutine may get garbage collected

rrva · Answer

so the first solution is actually better

ephemient · Answer

no better to pass in a scope as a parameter

rrva · Answer

ok lets say this scope is not available at object construction

ephemient · Answer

then try to restructure so that you have a scope or don t launch anything in init

rrva · Answer

try 3 ```class ChannelWorker private val requestChannel = Channel lt FooRequest gt private val responseChannel = Channel lt FooResult gt private var isRunning = Semaphore 1 private suspend fun start = coroutineScope if isRunning tryAcquire launch println Current scope $this for message in requestChannel val resp = fetchStuff message id responseChannel send FooResult resp private suspend fun fetchStuff id String Int delay 1000 return id toInt suspend fun requestFoo id String Int start requestChannel send FooRequest id val result = responseChannel receive return result result ```

ephemient · Answer

that likely doesn t do what you want structured concurrency enforces that `start ` will not return to the caller until all its children jobs are complete

rrva · Answer

even the launched ones

rrva · Answer

ok

rrva · Answer

so how do I do it it seems async is not available in kotlin mpp

rrva · Answer

try 4 ```class ChannelWorker private val requestChannel = Channel lt FooRequest gt private val responseChannel = Channel lt FooResult gt private var isRunning = Semaphore 1 suspend fun start scope CoroutineScope scope launch if isRunning tryAcquire println Current scope $this for message in requestChannel val resp = fetchStuff message id responseChannel send FooResult resp private suspend fun fetchStuff id String Int delay 1000 return id toInt suspend fun requestFoo id String Int requestChannel send FooRequest id val result = responseChannel receive return result result ```

ephemient · Answer

in general a function should be `suspend` receive a `CoroutineScope` or neither but not both in this case `start` does not need to be `suspend` but this is closer

ephemient · Answer

on a different note `requestFoo` is not safe for concurrency

ephemient · Answer

there is no guarantee that if you make two simultaneous `requestFoo ` calls that the two `responseChannel receive ` will execute in the same order that the two `requestChannel send ` were executed in

ephemient · Answer

and if it s not safe for concurrency I don t see what the point of this whole class could be

rrva · Answer

yeah I have to create a separate request response channel for each call to requestFoo

rrva · Answer

and in that case

rrva · Answer

```data class FooRequest val id String val responseChannel Channel lt FooResult gt data class FooResult val result Int class ChannelWorker private val requestChannel = Channel lt FooRequest gt private var isRunning = Semaphore 1 fun start scope CoroutineScope scope launch if isRunning tryAcquire println Current scope $this for message in requestChannel val resp = fetchStuff message id message responseChannel send FooResult resp private suspend fun fetchStuff id String Int delay 1000 return id toInt suspend fun requestFoo id String Int val responseChannel = Channel lt FooResult gt requestChannel send FooRequest id responseChannel val result = responseChannel receive return result result ```

ephemient · Answer

I mean what does this gain you over calling `fetchStuff ` directly if you want to ensure serial calls then use an existing sync mechanism

rrva · Answer

I would like to ensure serial calls yes

rrva · Answer

basically a LoadingCache like behavior If cache empty fetch Ensure that two fetch requests do not execute concurrently This is even ok if different keys want refresh in this scenario Ensure just one concurrent fetch

rrva · Answer

you mean just use a Semaphore directly

ephemient · Answer

```val mutex = Mutex suspend fun requestFoo id String Int = mutex withLock fetchStuff id ``` no need for any persistent scope or channels

rrva · Answer

hmm thanks

rrva · Answer

so expanded to handle a crude cache ``` val mutex = Mutex val cache = HashMap lt String Int gt suspend fun requestFoo id String Int return mutex withLock val cachedResult = cache id if cachedResult = null cachedResult else val fetched = fetchStuff id cache id = fetched fetched ```

ephemient · Answer

stylistically use `mutableMapOf lt String Int gt ` unless you have a particular need for the specific `HashMap` type and the whole body within `mutex withLock ` can be replaced by ```cache getOrPut id fetchStuff id ```

ephemient · Answer

but essentially yes