Jaka jest różnica między uruchomieniem / dołączeniem a asynchronicznym / oczekującym w koroutinach Kotlin

Znajduję ten poradnik https://github.com/Kotlin/kotlinx.coroutines/blob/master/coroutines-guide.md być użytecznym. Przytoczę najważniejsze części

Coroutine

Zasadniczo koroutiny są nićmi lekkimi.

Więc możesz myśleć o coroutine jako o czymś, co zarządza wątkiem w bardzo skuteczny sposób.

Start

fun main(args: Array<String>) {
    launch { // launch new coroutine in background and continue
        delay(1000L) // non-blocking delay for 1 second (default time unit is ms)
        println("World!") // print after delay
    }
    println("Hello,") // main thread continues while coroutine is delayed
    Thread.sleep(2000L) // block main thread for 2 seconds to keep JVM alive
}

Więc launch uruchamia wątek w tle, robi coś i zwraca token natychmiast jako Job. Możesz wywołać join na tym Job, aby zablokować, dopóki ten launch wątek nie zakończy się

fun main(args: Array<String>) = runBlocking<Unit> {
    val job = launch { // launch new coroutine and keep a reference to its Job
        delay(1000L)
        println("World!")
    }
    println("Hello,")
    job.join() // wait until child coroutine completes
}

Async

Koncepcyjnie async jest jak launch. Rozpoczyna oddzielną koronę, która jest lekką nicią, która działa jednocześnie ze wszystkimi innymi koronami. Różnica polega na tym, że launch zwraca zadanie i nie niesie żadnej wynikowej wartości, podczas gdy async zwraca odroczoną -- lekką, nieblokującą przyszłość, która reprezentuje obiecaj, że dostarczysz wynik później.

Więc async uruchamia wątek w tle, robi coś i natychmiast zwraca token jako Deferred.

fun main(args: Array<String>) = runBlocking<Unit> {
    val time = measureTimeMillis {
        val one = async { doSomethingUsefulOne() }
        val two = async { doSomethingUsefulTwo() }
        println("The answer is ${one.await() + two.await()}")
    }
    println("Completed in $time ms")
}

Możesz użyć .wait () na wartości odroczonej, aby uzyskać jej ostateczny wynik, ale Deferred jest również zadaniem, więc możesz ją anulować w razie potrzeby.

Więc Deferred jest w rzeczywistości Job. Zobacz też https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.experimental/-deferred/index.html

interface Deferred<out T> : Job (source)

Async domyślnie jest chętny

Istnieje możliwość asynchronizacji za pomocą opcjonalnego parametru start o wartości CoroutineStart.Leniwy. Uruchamia się tylko wtedy, gdy jego wynik jest potrzebny przez niektórych lub gdy wywołana jest funkcja start.