Coroutine to lekki wątek wykonania, który można zawiesić i wznowić później. Istnieje już wiele artykułów lub tematów na ten temat, ale ten post jest inny, jest prosty i może ułatwić rozpoczęcie pracy. Obejmie następujące części:

Przegląd

Podobnie jak wiele innych języków programowania, takich jak JS, Python, Coroutine to funkcja dostarczana przez Kotlin, która umożliwia nam wykonywanie długich i czasochłonnych zadań. W skrócie:

W Kotlinie Coroutines to sposób na pisanie asynchronicznego, nieblokującego kodu w bardziej sekwencyjny, łatwy do odczytania sposób.

Właściwie nie ma tu nic nowego. Możemy traktować Kotlin Coroutine jako framework/bibliotekę, która hermetyzuje niektóre typowe zastosowania podczas radzenia sobie z asynchronizacją.

Proste przykłady wykorzystania współprogramów w Kotlinie

Aby korzystać z coroutines w Kotlinie, musisz dołączyć kotlinx-coroutines-corebibliotekę do swojego projektu. W pliku gradle aplikacji (w projekcie IntelliJ jest tylko jeden plik gradle lub wybierz plik gradle dla aplikacji, jeśli jest to projekt Android), dodaj następujący wiersz:

dependencies {
    testImplementation(kotlin("test-junit"))
    implementation(kotlin("stdlib-jdk8"))
    // add coroutine dependency
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.2")
}

1. Użyj launchdo tworzenia współprogramów

Oto przykład użycia współprogramu do wykonania długotrwałego zadania w tle:

import kotlinx.coroutines.*

fun main() {
    // Start a coroutine using the launch function
    val job = GlobalScope.launch {
        // Perform a long-running task in the background
        delay(1000L)
        println("Hello, world!")
    }

    // Wait for the coroutine to finish
    runBlocking {
        job.join()
    }
}

2. Używaj asyncdo tworzenia współprogramów

Oto przykład użycia coroutines w Kotlinie do wykonywania wielu zadań równolegle, a następnie czekania, aż wszystkie się zakończą:

import kotlinx.coroutines.*

fun main() {
    // Start two coroutines using the async function
    val job1 = GlobalScope.async {
        // Perform a long-running task in the background
        delay(1000L)
        println("Task 1")
    }

    val job2 = GlobalScope.async {
        // Perform a different long-running task in the background
        delay(2000L)
        println("Task 2")
    }

    // Wait for both coroutines to finish
    runBlocking {
        job1.await()
        job2.await()
    }
}

Różnica między uruchomieniem a asynchronizacją w celu rozpoczęcia współprogramu

Oba są powszechnie używane do rozpoczęcia współprogramu. Główna różnica między nimi polega na tym, że launchzwraca Zlecenie (nieblokująca, anulowalna przyszłość) i nie zwraca wyniku, podczas gdy asynczwraca Odroczoną (nieblokującą, anulowalną przyszłość z wynikiem), której można użyć do uzyskania wyniku współprogram. Biorąc pod uwagę różnicę, kiedy należy użyć uruchamiania i asynchronizacji do tworzenia współprogramów:

• Kiedy użyjesz launchfunkcji, współprogram będzie działał w tle, a wywołanie funkcji zostanie natychmiast przywrócone. Jest używany, gdy wynik współprogramu nie jest potrzebny.
• Kiedy użyjesz asyncfunkcji, współprogram będzie również działał w tle, a wywołanie funkcji powróci natychmiast, ale zwróci obiekt, Deferredna którym możesz wywołać funkcję .await() w celu uzyskania wyniku współprogramu. Jest używany, gdy potrzebny jest wynik współprogramu. Na przykład:

val result = GlobalScope.async {
        return@async URL("https://api.example.com/data").readText()
    }
val data = result.await()
println(data)
// output: {"fact":"A group of cats is called a \u201cclowder.\u201d","length":38}

Co więcej stąd? Jak wiemy, Coroutine to duży temat i niewielu użytkowników może to wszystko wyjaśnić. To pierwszy artykuł z serii Coroutine. Jeśli jesteś zainteresowany, zasubskrybuj więcej nadchodzących postów na ten temat:

• Nieblokowanie w Kotlin Coroutines (przychodzące w tym tygodniu)
• Uruchamianie i zawieszanie Coroutine w Kotlinie (w tym tygodniu)

Pierwotnie opublikowane na stronie https://needone.app 16 stycznia 2023 r.