[yotamarker]

I am studymaxing it now, and let me tell you ! you can forget about threads.
coroutines are far more light weight so you can summon even a million async coroutines. pause and resume code blocks and
set their context. if you want that speed beef up for your AGI, you need to study this. it is now available for use in android studio 4.1 you
just need to add one dependency line of code in the gradle file tbh ngl.

[yotamarker]

Code

package com.yotamarker.kotlincoro1.playground.fundamentals

import android.arch.lifecycle.ViewModel
import android.support.annotation.RestrictTo
import kotlinx.coroutines.*
import java.util.concurrent.ExecutorService
import java.util.concurrent.Executors
import kotlin.time.ExperimentalTime
import kotlin.time.measureTime
//@Volatile var fudge = "fudge" //wherever this var is accessed from it will retrieve or save the latest value
var dClassesLv1 = ArrayList<String>()
var sum = 0;
@ExperimentalTime
fun main()= runBlocking{
    dClassesLv1.add("test1");dClassesLv1.add("test2");dClassesLv1.add("test3");dClassesLv1.add("test4");dClassesLv1.add("test5")
    for (i in 1..1000000) {
        dClassesLv1.add("added$i")
    }
    val duration = measureTime {launch(Dispatchers.Default){
        var finished :Boolean = false;
        repeat(dClassesLv1.size){ index ->
            inOut(dClassesLv1.get(index),"ear","skin","eye")
        }}.join()}
        //job.join()
    if(sum>0){
        println("success")
    println(sum);println("duration $duration")}
    val duration2 = measureTime {for (i in 0..dClassesLv1.size-1) {
        inOut(dClassesLv1.get(i),"ear","skin","eye")
    }}
    println("duration1(coroutine) = $duration duration2 = $duration2 sum= $sum")
    }
fun inOut(dClass:String, ear:String, skin:String, eye:String) {
    //mock function
    //print("$ear $skin $eye ")
    //println(dClass)
    sum = sum +1
}

code lines without printing : duration : sync code lines run time, duration2 coroutines async code lines run time
100m : glitches
10m : duration1(coroutine) = 86.9ms duration2 = 50.5ms sum= 20000010
1m : duration1(coroutine) = 47.4ms duration2 = 12.2ms sum= 2000010
100k : duration1(coroutine) = 42.7ms duration2 = 5.81ms sum= 200010
10k: duration1(coroutine) = 40.5ms duration2 = 895us
1k :duration1(coroutine) = 36.3ms duration2 = 160us sum= 2010
100 : duration1(coroutine) = 37.1ms duration2 = 80.8us sum= 210

[yotamarker]

Code

package com.yotamarker.kotlincoro1.playground.fundamentals

import android.arch.lifecycle.ViewModel
import android.support.annotation.RestrictTo
import kotlinx.coroutines.*
import java.util.concurrent.ExecutorService
import java.util.concurrent.Executors
import kotlin.time.ExperimentalTime
import kotlin.time.measureTime
//@Volatile var fudge = "fudge" //wherever this var is accessed from it will retrieve or save the latest value
var dClassesLv1 = ArrayList<String>()
var sum = 0;
@ExperimentalTime
fun main()= runBlocking{
    val duration = measureTime {
        exampleAsyncAwait()
    }
    print("async duration = $duration sum $sum")
    val duration2 = measureTime {
        for (i in 0..1000-1) {
            inOut2(dClassesLv1.get(i),"ear","skin","eye")
        }
    }
    print("  sync duration = $duration2 sum $sum")
}

suspend  fun inOut2(get: String, s: String, s1: String, s2: String) {
    delay(10)
    sum=sum+1
}

suspend fun calculateHardThings(startNum: Int): Int {
    delay(1000)
    return startNum * 10
}
fun exampleAsyncAwait() = runBlocking {
    for (i in 1..10000) {
        dClassesLv1.add("test1")
    }
    val startTime = System.currentTimeMillis()
    for (i in 0..10000-1) {
        if(i==9999){async { inOut(dClassesLv1.get(i),"ear","skin","eye") }.join();break}
        async { inOut(dClassesLv1.get(i),"ear","skin","eye") }
    }
    println("async/await result = $sum")

    val endTime = System.currentTimeMillis()
    println("Time taken: ${endTime - startTime}")
}
suspend fun inOut(dClass:String, ear:String, skin:String, eye:String) {
    //mock function
    //print("$ear $skin $eye ")
    //println(dClass)
    delay(10)
    sum = sum +1
}

async/await result = 10000
Time taken: 146
async duration = 151ms sum 10000  sync duration = 15.5s sum 11000
Process finished with exit code 0

so you only see a speed up with real heavy functions. so I guess for image recognition this could work