Co to są współprogramy?

Coroutines pomagają zarządzać długotrwałymi zadaniami, które w przeciwnym razie mogłyby zablokować główny wątek i spowodować, że aplikacja przestanie odpowiadać. Współprogram to wzorzec projektowy współbieżności, którego można użyć w systemie Android w celu uproszczenia kodu, który jest wykonywany asynchronicznie.

Jak widać na powyższym diagramie, w głównym wątku możesz wykonywać tylko małe operacje. Jeśli chcesz wykonywać długotrwałe operacje w głównym wątku, Twoja aplikacja może ulegać awariom i działać wolno. Lub jeśli utworzysz nr. tła/wątku roboczego, a następnie nadchodzi problem braku pamięci. Coroutines to specjalny typ funkcji, który celowo przekazuje kontrolę wywołującemu, ale nie kończy swojego kontekstu w procesie, zamiast tego utrzymuje go w stanie bezczynności.

Jak korzystać z Coroutines?

dependencies {
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:x.x.x"
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:x.x.x"
}

• Główny: używa wątku interfejsu użytkownika. W Rx jest podobny do AndroidSchedulers.MainThread()
• Domyślnie: używany do zadań intensywnie korzystających z procesora . Będzie wykorzystywać tyle wątków, ile dostępnych jest rdzeni procesora. Ponieważ są to zadania intensywnie korzystające z procesora, nie ma sensu uruchamiać wielu wątków, ponieważ procesor będzie zajęty. Podobne do Schedulers.computation() w Rx.
• IO: używane do wejścia/wyjścia. Wysłanie żądania do API, dostęp do bazy danych itp. Podobne do Schedulers.io() w Rx.
• Zadanie: Zasadniczo jest to zadanie, które działa w tle i może być interpretowane jako akcja, której cykl życia ulega zniszczeniu po zakończeniu.
• Do uruchamiania różnych operacji przy użyciu zadań: Job.join
• For anuluje wszystkie zadania podrzędne: Job.cancel
• withContext: inny sposób pisania async, w którym nie musimy pisać await().

suspend fun fetchUser() = withContext(Dispatchers.IO) {
        // make network call
        // return 
}

Suspend : Jak sugeruje ich nazwa, są to funkcje, które w pewnym momencie zawieszają wykonanie współprogramu, a następnie wznawiają wykonywanie funkcji, gdy wynik jest gotowy.

suspend fun makeNetworkRequest() {
    // fetchData is another suspend function, so 'makeNetworkRequest' is going to be `suspended`
    // until it's result becomes available, without blocking the main thread.
    val result = fetchData()
    // continues executing once the result becomes available
    show(result)
}

// fetchData is main thread safe
suspend fun fetchData(): Result { ... }

Uruchomienie nie zablokuje głównego wątku, ale z drugiej strony wykonanie reszty kodu nie będzie czekać na wynik uruchomienia, ponieważ uruchomienie nie jest wywołaniem zawieszenia.

fun GFG()
{
    var resultOne = "Android"
    var resultTwo = "Kotlin"
    Log.i("Launch", "Before")
    launch(Dispatchers.IO) { resultOne = function1() }
    launch(Dispatchers.IO) { resultTwo = function2() }
    Log.i("Launch", "After")
    val resultText = resultOne + resultTwo
    Log.i("Launch", resultText)
}

suspend fun function1(): String
{
    delay(1000L)
    val message = "function1"
    Log.i("Launch", message)
    return message
}

suspend fun function2(): String
{
    delay(100L)
    val message = "function2"
    Log.i("Launch", message)
    return message
}

Async jest również używany do uruchamiania współprogramów, ale blokuje główny wątek w punkcie wejścia funkcji await() w programie.

fun GFG
{
    Log.i("Async", "Before")
    val resultOne = Async(Dispatchers.IO) { function1() }
    val resultTwo = Async(Dispatchers.IO) { function2() }
    Log.i("Async", "After")
    val resultText = resultOne.await() + resultTwo.await()
    Log.i("Async", resultText)
}

suspend fun function1(): String
{
    delay(1000L)
    val message = "function1"
    Log.i("Async", message)
    return message
}

suspend fun function2(): String
{
    delay(100L)
    val message = "function2"
    Log.i("Async", message)
    return message
}

Korzyści z używania Coroutines

• Coroutines to lekkie wątki
• Coroutines mogą działać równolegle, czekać na siebie i komunikować się ze sobą
• Twórz tysiące współprogramów bez problemów z pamięcią
• Najlepsze do nowoczesnych aplikacji