How to do conditional async execution?

interface TestPreconditionVoter {
    fun vote(context: Map<String, Any>): Vote
}

and voters = List<TestPreconditionVoter>() Based on a given boolean flag, I’d like to do the following:

1. if true, execute vote parallelly.
2. Otherwise. execute them sequentially.

Optionally, I’d like to replace the Map<String, Any> with something from the CoroutineContext that can be used as a temporary bag of data to pass from one voter to another. Note that in the first case, such data structure would have to be thread safe.

What’d be an idiomatic way to do this? Currently I’ve the following WIP code but I suspect there is a better way.

runBlocking {
    withTimeout(vote.timeoutMillis, TimeUnit.MILLISECONDS) {
        if (vote.castingStrategy == PARALLEL) {
            voters
                .map { async { it.vote(context) } }
                .groupBy({ it.await() }, { it.await() })
                .mapValues { it.value.size }
        } else {
            voters
                .map { it.vote(context) }
                .groupingBy { it }?.eachCount()
        }
    }
}

Kotlin 1.2.31, Coroutine 0.22.5

[qwwdfsad]

@asarkar

Could you be little more specific please?

Sure. Paragraph about suspending functions:

Suspending functions can take parameters and return values in the same manner as regular functions, but they can only be called from coroutines and other suspending functions, as well as function literals inlined into those.

groupingBy is not suspending function and is not inlined into caller (which is runBlocking block with type suspend CoroutineScope.() -> T), thus calling suspend function from groupingBy is prohibited. E.g. map method is defined as public inline fun <T, R> Iterable<T>.map and is inlined into block, so any suspend function can be called from map

[fvasco]

The code in your opening post apparently works.

Some considerations:

1. vote is not a suspending functions, so it completes always (regardless withTimeout)
2. async block is in a context different than withTimeout’s context, so it completes always (regardless withTimeout)
3. the async concurrency level is the DefaultExecutor concurrency level and it never invokes any suspendig function, so the parallelism is limited (the case is not the same in the guide).

That code is much or less the same of:

if (vote.castingStrategy == PARALLEL) {
            ForkJoinExecutor.submit(...).wait()
        } else {
            voters.map { it.vote(context) }.groupingBy { it }?.eachCount()
        }
if ( timeExpired ) throw CancellationException()

If the above statements are right then I suppose you should review your code, and the proposed refinement is not a great enhancement.

My friendly suggestion is to avoid coroutines for this use case, do it using multithread (or understand better how coroutine works).

Sorry for frankness, please do not read any arrogance in this lines, it isn’t absolutely my goal.

Good luck, Vasco