Is there a simple way to execute functions in parallel and w

Question

Is there a simple way to execute functions in parallel and wait until all are done All the examples I find when googling appear to expect a blocking style function instead of already async functions For instance I have multiple api endpoints I need to hit but I don t want to do the model screen refresh until all 3 have returned I ve simplified the prototype of the functions here a bit for explanatory purposes I definitely need to call some of these at other times and don t really want to change their prototype ```fun fetchActivities userName String completion List lt ActivityEntry gt gt Unit fun fetchMoves userName String completion List lt MoveEntry gt gt Unit fun fetchScores userName String completion List lt ScoreEntry gt gt Unit ```

Michael Langford · Answer

I believe I m looking for something similar to pthread s barrier etc

Igor Milakovic · Answer

Unfortunately I don t know for Kotlin but in iOS Swift land that would be called `DispatchGroup` it that helps with googling slightly smiling face

Michael Langford · Answer

Each of those functions calls Thread start btw

Michael Langford · Answer

yeah I know how to do it in swift smile

Oliver.O · Answer

Coroutines <https kotlinlang org docs coroutines basics html scope builder and concurrency>

Michael Langford · Answer

That s why I m trying to keep the pattern to not accidentally mess up some iOS code I m porting over semantically

Michael Langford · Answer

I don t have suspending functions that I m aware of

Oliver.O · Answer

You can call blocking functions from coroutines If these are scheduled by the IO dispatcher blocking won t hurt too much in simple scenarios

Michael Langford · Answer

These aren t blocking functions though

Oliver.O · Answer

What else are they

Michael Langford · Answer

```fun fetchActivities userName String completion List lt ActivityEntry gt gt Unit This executes after the network request has completed ```

Michael Langford · Answer

They each have a Thread do network call stuff start

Tim Oltjenbruns · Answer

You can wrap a completion style call into coroutines if you want to go that route

Tim Oltjenbruns · Answer

take a look at <https kotlin github io kotlinx coroutines kotlinx coroutines core kotlinx coroutines suspend cancellable coroutine html>

Oliver.O · Answer

Yep that s what I was just trying to look up

Michael Langford · Answer

oi thank you That looks exactly how I can wrap these up

Oliver.O · Answer

And then there s `callbackFlow` for more than one result

Tim Oltjenbruns · Answer

as for taking your multiple calls and waiting on all of them this is how I usually do it ```listOf async function1 async function2 async function3 awaitAll ```

Tim Oltjenbruns · Answer

makes it a bit trickier waiting on different return types so there s that part to work out not as simple as I have it above

Michael Langford · Answer

yeah if I don t have all three return values I get an inconsistent picture of the full state I know there is some hair there with partial failure etc But even how to actually wrap the type of function I have was hard to find callback was the word I was not searching for

Tim Oltjenbruns · Answer

makes it tricky coming from iOS where they call callbacks completions

Michael Langford · Answer

lol yeah indeed Amusingly this far more complex multiple callback thingy is only really required on pull to refresh

Michael Langford · Answer

is callbackFlow parallelizable

Tim Oltjenbruns · Answer

it s verbose but it s the simplest way I can think of to get it done off the top of my head ```val activitiesDeferred = async activites val movesDeferred = async moves val scoresDeferred = async scores val activities = activitiesDeferred await val moves = movesDeferred await val scores = scoresDeferred await ```

Tim Oltjenbruns · Answer

callbackflow would be more for returning multiple of the same type

Tim Oltjenbruns · Answer

or maybe even a building state that accumulates over time

Michael Langford · Answer

Oh that makes sense

Tim Oltjenbruns · Answer

```data class FullData val activities Result lt List lt ActivityEntry gt gt val moves Result lt List lt MoveEntry gt gt val scores Result lt List lt ScoreEntry gt gt ```

Tim Oltjenbruns · Answer

I would only go that route if the intermediate state were valuable to me

Tim Oltjenbruns · Answer

because then as your different api calls return it starts filling out this state and you can action on partial data

Tim Oltjenbruns · Answer

If it s really all or nothing I d go with the sadly inelegant first solution of just declaring 3 async s and awaiting them all individually

Michael Langford · Answer

eh it s only kind of all or nothing

Michael Langford · Answer

The world is inconsistent if one of the three fails but they can partially fail etc

Tim Oltjenbruns · Answer

gt is callbackFlow parallelizable It can be but that depends more on the implementation of your Thread situation that happens behind the scenes A flow can be set on the IO dispatcher which is a big threadpool But that won t really matter because you have your own threads inside the implementations

Michael Langford · Answer

I assumed with your 3 asyncs followed by 3 awaits the asyncs would each launch their own internal threads and then the 3 awaits would essentially collect it all

Michael Langford · Answer

```val activitiesDeferred = async activites val movesDeferred = async moves val scoresDeferred = async scores val activities = activitiesDeferred await val moves = movesDeferred await val scores = scoresDeferred await ```

Michael Langford · Answer

that guy

Tim Oltjenbruns · Answer

With coroutines each concurrent coroutine is not necessarily it s own thread

Tim Oltjenbruns · Answer

Coroutines achieves concurrency without multiple threads

Tim Oltjenbruns · Answer

But to answer your question those three async blocks kick off concurrently and eagerly yes And then the awaits wait until all of them finish

Michael Langford · Answer

apologies I didn t mean in general they work that way

Michael Langford · Answer

I meant for my particular 3 functions which already go Thread doNetworkingStuff start

Tim Oltjenbruns · Answer

Ah yes so in that situation you have your three threads that kick off and whatever thread is waiting for them to finish

Tim Oltjenbruns · Answer

The thread that waits for them to finish is determined by what Dispatcher is in the CoroutineScope your `async` block is called from

Michael Langford · Answer

Tim I just want to say I finally got all the error handling in through your triple async solution it works gloriously well Thank you Its so flexible and works so cleanly I can handle sub errors in each decode partial failures etc