0Pricing
Kotlin Academy · Aula

Tipos de Channel: rendezvous, com buffer, conflated e ilimitado

Escolha o tipo de canal adequado ao seu padrão de comunicação.

Tipos de Channel: rendezvous, com buffer, conflated e ilimitado é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 2 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.

Fábrica de canais

Crie canais com Channel<T>(capacity). A capacidade determina o armazenamento em buffer e o comportamento de suspensão.

import kotlinx.coroutines.channels.Channel
val rendezvous = Channel<Int>()              // capacity 0
val buffered   = Channel<Int>(64)            // capacity 64
val unlimited  = Channel<Int>(Channel.UNLIMITED)
val conflated  = Channel<Int>(Channel.CONFLATED)
fun main() { println("Channel types created") }

Canal de encontro (capacidade=0)

Canal padrão. send é suspenso até que um receptor esteja pronto, e receive é suspenso até que um remetente envie. Eles se encontram no mesmo ponto.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
    val ch = Channel<Int>() // rendezvous
    launch {
        println("Sending...")
        ch.send(1)  // suspends until receiver is ready
        println("Sent")
    }
    delay(100)
    println("Receiving...")
    println(ch.receive())
}

Canal com buffer

Um canal com buffer permite que o remetente continue sem esperar até que o buffer esteja cheio. Quando está cheio, send é suspenso.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
    val ch = Channel<Int>(3) // buffer of 3
    launch {
        repeat(3) {
            println("Sending $it")
            ch.send(it) // does not suspend until buffer full
        }
        ch.close()
    }
    delay(500)
    for (v in ch) println("Got $v")
}

Canal.BUFFERED

Channel.BUFFERED usa a capacidade padrão (64). Isso equivale a Channel(64).

import kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.*
fun main() = runBlocking {
    val ch = Channel<String>(Channel.BUFFERED)
    println("Default buffer capacity is implementation-defined (~64)")
    ch.close()
}

Canal ilimitado

Channel.UNLIMITED nunca suspende o remetente — armazena todos os valores. Use com cuidado: pode haver crescimento ilimitado do uso de memória.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
    val ch = Channel<Int>(Channel.UNLIMITED)
    launch {
        repeat(1000) { ch.send(it) } // never suspends
        ch.close()
    }
    var sum = 0
    for (v in ch) sum += v
    println("Sum: $sum")
}

Canal que mantém o valor mais recente

Channel.CONFLATED mantém apenas o valor mais recente. Se um novo valor chegar antes que o anterior seja recebido, o antigo será descartado.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
    val ch = Channel<Int>(Channel.CONFLATED)
    launch {
        repeat(5) { ch.send(it) } // 0..4 sent rapidly
        ch.close()
    }
    delay(50) // let all sends happen
    println("Received: ${ch.tryReceive().getOrNull()}") // likely 4 (last)
}

RENDEZVOUS versus BUFFERED: temporização

O canal de encontro sincroniza o produtor e o consumidor. O canal com buffer permite que o produtor avance, desacoplando a temporização.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
    val ch = Channel<Int>(Channel.BUFFERED)
    val t = System.currentTimeMillis()
    launch {
        repeat(5) { ch.send(it) } // fast — doesn't wait
        ch.close()
    }
    for (v in ch) { delay(100); println("$v at ${System.currentTimeMillis()-t}ms") }
}

Estratégia onBufferOverflow

Com Channel(capacity, onBufferOverflow), escolha o que acontece quando o buffer está cheio: SUSPEND (padrão), DESCARTAR_MAIS_ANTIGO ou DESCARTAR_MAIS_RECENTE.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
    val ch = Channel<Int>(2, BufferOverflow.DROP_OLDEST)
    launch {
        repeat(5) { ch.trySend(it) } // 0,1,2,3,4 — buffer keeps newest 2
        ch.close()
    }
    for (v in ch) println(v) // likely 3 4
}

Escolhendo o tipo de canal

Guia de decisão: encontro para sincronização rigorosa; com buffer para vazão; canal que mantém apenas o valor mais recente para valores mais recentes (como o estado da interface); ilimitado para registro de eventos quando a perda é inaceitável.

import kotlinx.coroutines.channels.Channel
// Use cases:
// RENDEZVOUS  — handshake between producer and consumer
// BUFFERED    — decouple I/O-heavy producer from slow consumer
// CONFLATED   — UI updates (only latest matters)
// UNLIMITED   — audit log (never drop)
fun main() { println("Choose based on your loss tolerance and timing needs") }

Canal em seleção

select permite esperar simultaneamente em vários canais, escolhendo o primeiro que estiver pronto.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
import kotlinx.coroutines.selects.*
fun main() = runBlocking {
    val a = produce { delay(100); send("from a") }
    val b = produce { delay(50);  send("from b") }
    val result = select<String> {
        a.onReceive { it }
        b.onReceive { it }
    }
    println(result) // "from b"
    coroutineContext.cancelChildren()
}

Canal temporizador

ticker(delay) cria um canal que emite Unit a cada delay milissegundos — útil para consultas repetidas.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
    val ticker = ticker(delayMillis = 100, initialDelayMillis = 0)
    var count = 0
    for (tick in ticker) {
        println("Tick ${++count}")
        if (count == 3) { ticker.cancel(); break }
    }
}

Verificação rápida

Qual tipo de canal mantém apenas o valor mais recente?

Recapitulação

Encontro: sincronizado, sem buffer. Com buffer: desacopla a temporização. Valor mais recente: mantém apenas o valor mais recente e descarta os antigos. Ilimitado: nunca suspende o remetente. Escolha com base na tolerância à perda e nas necessidades de vazão.

Perguntas Frequentes

A aula “Tipos de Channel: rendezvous, com buffer, conflated e ilimitado” é grátis?

Sim — o texto completo de “Tipos de Channel: rendezvous, com buffer, conflated e ilimitado” é 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 “Tipos de Channel: rendezvous, com buffer, conflated e ilimitado”?

Escolha o tipo de canal adequado ao seu padrão de comunicação. 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 2 de 4.

Quanto tempo leva a aula “Tipos de Channel: rendezvous, com buffer, conflated e ilimitado”?

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