CODEWITHSUNDEEP
kotlinjvmkotlin-coroutines
Tech Drago
Tech Drago

Reputation: 37

coroutine scope and async - right approach?

I love the concept of co-routines and I've been using in my android projects. Currently i'm working on a JVM module which i'll be including in a Ktor project and i know ktor has support for co-routines.

(find the attached code snippet)

Just wanted to know is this the right approach? How do i use async with recursion?

Any resources that you can recommend which can help me grasp more in-depth knowledge of co-routines would be helpful.

Thanks in advance!

override suspend fun processInstruction(args.. ): List<Any> = coroutineScope {

 val dataWithFields = async{       
     listOfFields.fold(mutableList()){ acc,field ->
    val data = someProcess(field)
    val nested = processInstruction(...nestedField) // nested call

    acc.addAll(data)
    acc.addAll(nested)
    acc
}
}

return@coroutineScope postProcessData(dataWithFields.await())

}

Upvotes: 0

Views: 5072

Answers (1)

IlyaMuravjov
IlyaMuravjov

Reputation: 2502

If you want to process all nested calls in parallel, you should wrap each of them in async (async should be inside of the loop). And then, after the loop, you should await all the results. (In your code you run await right after single async, so there is no parallel execution).

For example, if you have Element:

interface Element {
    val subElements: List<Element>
    suspend fun calculateData(): SomeData
}

interface SomeData

And you want to calculateData of all subElements in parallel, you can do it like this:

suspend fun Element.calculateAllData(): List<SomeData> = coroutineScope {
    val data = async { calculateData() }
    val subData = subElements.map { sub -> async { sub.calculateAllData() } }
    return@coroutineScope listOf(data.await()) + subData.awaitAll().flatten()
}

As you said in a comments section, you need parent-data to calculate sub-data, therefore the first thing calculateAllData() should do is calculate the parent-data:

suspend fun Element.calculateAllData(
    parentData: SomeData = defaultParentData()
): List<SomeData> = coroutineScope {
    val data = calculateData(parentData)
    val subData = subElements.map { sub -> async { sub.calculateAllData(data) } }
    return@coroutineScope listOf(data) + subData.awaitAll().flatten()
}

Now you may wonder how fast it works. Consider the following Element implementation:

class ElementImpl(override val subElements: List<Element>) : Element {
    override suspend fun calculateData(parentData: SomeData): SomeData {
        delay(1000)
        return SomeData()
    }
}

fun elmOf(vararg elements: Element) = ElementImpl(listOf(*elements))

And the following test:

println(measureTime {
    elmOf(
        elmOf(),
        elmOf(
            elmOf(),
            elmOf(
                elmOf(),
                elmOf(),
                elmOf()
            )
        ),
        elmOf(
            elmOf(),
            elmOf()
        ),
        elmOf()
    ).calculateAllData()
})

If parent-data isn't needed to calculate sub-data, it prints 1.06s, since in this case, all the data is calculated in parallel. Otherwise, it prints 4.15s, since elements tree height is 4.

Upvotes: 1

Related Questions