Introdução à corrotina em Kotlin

Jan 17 2023

Uma Coroutine é um thread leve de execução que pode ser suspenso e retomado posteriormente. Já existem muitos artigos ou tópicos abordando isso, mas este post é diferente, é simples e permite que você comece com mais facilidade.

Visão geral

Como muitas outras linguagens de programação, como JS, Python, Coroutine é um recurso fornecido pelo Kotlin que nos permite executar tarefas longas e demoradas. Resumidamente:

Em Kotlin, Coroutines são uma maneira de escrever código assíncrono e sem bloqueio de uma maneira mais sequencial e fácil de ler.

Na verdade, nada de novas técnicas aqui. Podemos tratar Kotlin Coroutine como uma estrutura/biblioteca que encapsula alguns usos comuns enquanto lida com a assincronização.

Exemplos simples de uso de corrotinas em Kotlin

Para usar corrotinas em Kotlin, você precisa incluir a kotlinx-coroutines-corebiblioteca em seu projeto. No arquivo gradle do seu aplicativo (há apenas um arquivo gradle no projeto IntelliJ ou escolha o arquivo gradle para o aplicativo se for um projeto Android), adicione a seguinte linha:

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

1. Use `launch`para criar corrotinas

Aqui está um exemplo de uso de uma corrotina para executar uma tarefa de execução longa em segundo plano:

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. Use `async`para criar corrotinas

Aqui está um exemplo de uso de corrotinas em Kotlin para executar várias tarefas em paralelo e aguardar a conclusão de todas:

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()
    }
}

A diferença entre lançamento e assíncrono para iniciar uma corrotina

Ambos são comumente usados para iniciar uma co-rotina. A principal diferença entre os dois é que launchretorna um Job (um futuro cancelável sem bloqueio) e não retorna um resultado, enquanto asyncretorna um Deferred (um futuro cancelável sem bloqueio com um resultado) que pode ser usado para obter o resultado de a corrotina. Considerando a diferença, quando deve usar o launch e o async para criar corrotinas:

Quando você usa launcha função, a co-rotina será executada em segundo plano e a chamada da função retornará imediatamente. É usado quando o resultado da co-rotina não é necessário.
Quando você usa asynca função, a corrotina também será executada em segundo plano e a chamada da função retornará imediatamente, mas retornará um Deferredobjeto no qual você pode chamar a função .await() para obter o resultado da corrotina. É usado quando o resultado da co-rotina é necessário. Por exemplo:

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}

O que é mais daqui? Como sabemos, Coroutine é um grande tópico e poucos wears podem explicar tudo isso. Este é o primeiro artigo da série Coroutine. Se você estiver interessado, inscreva-se para mais postagens futuras sobre isso: