PricingLoginStart free
Kotlin Academy · Aula

Noções básicas de Channel: send, receive e close

Crie canais, envie e receba valores e feche-os corretamente.

Aula 1 de 413 etapas

Noções básicas de Channel: send, receive e close é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Kotlin Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Kotlin Academy inclui 4 aulas no total.

O que é um canal?

Um Channel é uma primitiva de corrotina para comunicação entre corrotinas — como uma fila bloqueante, mas suspensa. Pense nele como um tubo: um lado envia e o outro recebe.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
    val channel = Channel<Int>()
    launch {
        for (i in 1..5) channel.send(i)
        channel.close()
    }
    for (x in channel) println(x) // 1 2 3 4 5
}

send e receive

send(value) é suspenso até que o receptor esteja pronto. receive() é suspenso até que um valor esteja disponível.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
    val ch = Channel<String>()
    launch {
        ch.send("ping")
        println("sent")
    }
    val msg = ch.receive()
    println("received: $msg")
}

Fechando um canal

channel.close() sinaliza que nenhum outro valor será enviado. Os receptores obtêm os valores restantes armazenados no buffer e, em seguida, o laço termina.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
    val ch = Channel<Int>(3)
    launch {
        repeat(3) { ch.send(it) }
        ch.close()  // signal done
    }
    for (v in ch) println(v) // 0 1 2, then loop ends
    println("Channel consumed")
}

isClosedForSend / isClosedForReceive

Verifique o estado do canal com isClosedForSend (não são permitidos mais envios) e isClosedForReceive (todos os valores foram consumidos).

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
    val ch = Channel<Int>()
    launch {
        ch.send(1)
        ch.close()
    }
    println(ch.receive())
    println("isClosedForReceive: ${ch.isClosedForReceive}")
}

Construtor de produção

produce { } é um construtor de corrotina que cria uma corrotina produtora e retorna um ReceiveChannel. O canal é fechado automaticamente quando o bloco termina.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun CoroutineScope.squares(n: Int) = produce<Int> {
    for (i in 1..n) send(i * i)
}
fun main() = runBlocking {
    val sq = squares(5)
    for (v in sq) println(v) // 1 4 9 16 25
}

Extensão consumeEach

consumeEach { } itera sobre um canal e o cancela quando o bloco lança uma exceção, evitando vazamentos.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
    val ch = produce<String> {
        send("a"); send("b"); send("c")
    }
    ch.consumeEach { println(it) }
}

tryReceive e trySend

Alternativas que não suspendem: trySend / tryReceive retornam um ChannelResult imediatamente, sem suspender.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
    val ch = Channel<Int>(1)
    val sendResult = ch.trySend(42)
    println("Sent: ${sendResult.isSuccess}")
    val recvResult = ch.tryReceive()
    println("Got: ${recvResult.getOrNull()}")
}

Distribuição: vários consumidores

Várias corrotinas podem receber do mesmo canal, distribuindo o trabalho — um padrão de distribuição.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
    val tasks = produce { repeat(6) { send(it) } }
    repeat(3) { worker ->
        launch {
            for (task in tasks) {
                println("Worker $worker: task $task")
            }
        }
    }
}

Agregação: vários produtores

Várias corrotinas podem enviar para o mesmo canal, mesclando suas saídas — um padrão de agregação.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
    val results = Channel<String>()
    repeat(3) { i ->
        launch { results.send("result-$i") }
    }
    launch {
        repeat(3) { println(results.receive()) }
        results.close()
    }
}

Padrão de processamento em cadeia

Encadeie canais em uma cadeia de processamento na qual cada etapa lê de um canal e grava em outro — excelente para fluxos de trabalho de processamento de dados.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun CoroutineScope.numbers() = produce { for (i in 1..5) send(i) }
fun CoroutineScope.doubled(input: ReceiveChannel<Int>) = produce { for (v in input) send(v * 2) }
fun main() = runBlocking {
    val nums = numbers()
    val doubled = doubled(nums)
    for (v in doubled) println(v) // 2 4 6 8 10
    coroutineContext.cancelChildren()
}

Canal versus fluxo

Os canais são quentes e têm estado — existem independentemente do consumo. Os fluxos são frios e declarativos — reiniciam a cada coleta. Prefira Fluxo para fluxos de dados; use Canal para comunicação entre produtor e consumidor.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
import kotlinx.coroutines.flow.*
// Flow (cold): each collect() re-runs the block
// Channel (hot): shared; multiple receivers share the same stream
fun main() = runBlocking { println("Flow = cold; Channel = hot") }

Verificação rápida

O que acontece quando você chama channel.close()?

Responda na aula interativa

Recapitulação

send e receive são suspensos até que o outro lado esteja pronto. fechar() sinaliza a conclusão. Use produção para produtores que se fecham automaticamente, consumeEach para iteração segura e canais para padrões de distribuição e agregação.

Grátis para começar

Aprenda Kotlin com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos
51
Aulas
203
Começar a aprender grátisVer o curso completo

Perguntas Frequentes

A aula “Noções básicas de Channel: send, receive e close” é grátis?

Sim — o texto completo de “Noções básicas de Channel: send, receive e close” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Kotlin Academy, atualize para CoddyKit PRO. O curso de Kotlin Academy inclui 4 aulas no total.

O que vou aprender em “Noções básicas de Channel: send, receive e close”?

Crie canais, envie e receba valores e feche-os corretamente. Você pratica Kotlin Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Kotlin Academy?

Nenhuma experiência prévia é necessária. Kotlin Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Noções básicas de Channel: send, receive e close”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Kotlin Academy?

Sim. Cada aula de Kotlin Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Noções básicas de Channel: send, receive e close
  2. Tipos de Channel: rendezvous, com buffer, conflated e ilimitado
  3. Mutex e Semaphore para estado compartilhado
  4. Atores e gerenciamento estruturado de estado
← Voltar para Kotlin Academy