If I have, lets say 3 functions that write to a database. They are independent of each other (in tha...

# coroutines

[dharrigan]

If I have, lets say 3 functions that write to a database. They are independent of each other (in that the writes of one function does not affect the writes of another function into the db) and I want to run each in their own coroutine, not caring about any return code or status.

[marstran]

Well, the first example will run all writes in parallel while the second one will run the one after the other. So it just depends on what you want to do.

[dharrigan]

parallelism 🙂

[dharrigan]

what happens if I change the function signature to this?

[marstran]

Then you have to do the first one. The second one doesn’t run them in parallel.

[dharrigan]

suspend fun writeIntoTable1() = GlobalScope.launch {...}

[dharrigan]

I suppose then, each function would then run in parallel

[marstran]

Yes, but that is not idiomatic. A suspend function is expected to complete all work before it returns.

Also, you shouldn’t use GlobalScope. Your coroutines could leak.

[dharrigan]

I see I see

[dharrigan]

so the first approach would be better?

[marstran]

I think I would do this:

fun CoroutineScope.doSomething() {
    launch(<http://Dispatchers.IO|Dispatchers.IO>) {
        writeIntoTable1()
    }

    launch(<http://Dispatchers.IO|Dispatchers.IO>) {
        writeIntoTable2()
    }

    launch(<http://Dispatchers.IO|Dispatchers.IO>) {
        writeIntoTable3()
    }
}

[dharrigan]

great, how then is the doSoemthing invoked (to kick everything off?)

[marstran]

Let the caller decide the scope. Taking the CoroutineScope as the receiver parameter is a convention.

[uli]

But you can drop the suspend keyword bacause you are not suspending, but returning imediately: fun CoroutineScope.writeIntoTable1Async() = launch {...}

[dharrigan]

k

[marstran]

Call it like myScope.doSomething().

[marstran]

Yeah, that’s also a possibility @uli👍

[dharrigan]

ta! food for thought

[dharrigan]

🙂

[dharrigan]

works great, thank you both! 🙂

[uli]

how did you do it now?

[gildor]

It’s bad idea to implement it like this:
https://kotlinlang.slack.com/archives/C1CFAFJSK/p1565526111072300?thread_ts=1565525689.068700&cid=C1CFAFJSK

[gildor]

For example try to handle exception in this case. Or even worse if you want to cancel other operations if one of them failed
And copy dispatcher is also suboptimal.

Most probably it should look like:

suspend fun doSomething() { 
coroutineScope { // or withContext(IO) if you really need IO disaptcher
    launch {
        writeIntoTable1()
    }
    launch {
        writeIntoTable2()
    }
    launch {
        writeIntoTable3()
    }    
}
}

And on call site:

myLocalScope.launch { doSomething }

or any other semantics that suits better call site (use await, just call suspend function etc)

[dharrigan]

That's pretty much what I've distilled from the great advice here 🙂

[dharrigan]

Thank you 🙂