0Pricing
Kotlin Academy · Lección

Tipos de Channel: Rendezvous, Buffered, Conflated y Unlimited

Elija el tipo de canal adecuado para su patrón de comunicación.

Tipos de Channel: Rendezvous, Buffered, Conflated y Unlimited es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Kotlin Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Kotlin Academy incluye 4 lecciones en total.

Factoría de canales

Cree canales con Channel<T>(capacity). La capacidad determina el almacenamiento en búfer y el comportamiento de suspensión.

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 Rendezvous (capacity=0)

Es el canal predeterminado. send se suspende hasta que hay un receptor preparado y receive se suspende hasta que un emisor envía un valor. Ambos se sincronizan: se encuentran en el mismo punto.

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 con búfer

Un canal con búfer permite que el emisor continúe sin esperar hasta que el búfer se llena. Cuando está lleno, send se suspende.

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

Channel.BUFFERED

Channel.BUFFERED utiliza la capacidad predeterminada (64). 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 al emisor: almacena todos los valores en el búfer. Utilícelo con precaución, ya que puede provocar un crecimiento ilimitado del uso de memoria.

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 conflado

Channel.CONFLATED conserva únicamente el valor más reciente. Si llega un valor nuevo antes de recibir el anterior, el antiguo se descarta.

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

Temporización de RENDEZVOUS frente a BUFFERED

Rendezvous sincroniza al productor y al consumidor. Buffered permite que el productor se adelante y desacopla la temporización.

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

Estrategia onBufferOverflow

Con Channel(capacity, onBufferOverflow), elija qué sucede cuando el búfer está lleno: SUSPEND (predeterminado), DROP_OLDEST o DROP_LATEST.

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
}

Elegir el tipo de canal

Guía de decisión: Rendezvous para una sincronización estricta; Buffered para el rendimiento; Conflated para conservar únicamente el valor más reciente (como el estado de la interfaz de usuario); Unlimited para registrar eventos cuando no se puede perder ninguno.

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

Channel en select

select permite esperar simultáneamente en varios canales y seleccionar el primero que esté preparado.

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 ticker

ticker(delay) crea un canal que emite Unit cada delay milisegundos; resulta útil para realizar 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 }
    }
}

Comprobación rápida

¿Qué tipo de canal conserva únicamente el valor más reciente?

Resumen

Rendezvous: sincronizado, sin búfer. Buffered: desacopla la temporización. Conflated: conserva solo el valor más reciente y descarta los antiguos. Unlimited: nunca suspende al emisor. Elija según su tolerancia a la pérdida de datos y sus necesidades de rendimiento.

Preguntas frecuentes

¿La lección «Tipos de Channel: Rendezvous, Buffered, Conflated y Unlimited» es gratis?

Sí — el texto completo de «Tipos de Channel: Rendezvous, Buffered, Conflated y Unlimited» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Kotlin Academy, actualiza a CoddyKit PRO. El curso de Kotlin Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Tipos de Channel: Rendezvous, Buffered, Conflated y Unlimited»?

Elija el tipo de canal adecuado para su patrón de comunicación. Practicas Kotlin Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Kotlin Academy?

No se requiere experiencia previa. Kotlin Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Tipos de Channel: Rendezvous, Buffered, Conflated y Unlimited»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Kotlin Academy?

Sí. Cada lección de Kotlin Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Fundamentos de Channel: send, receive y close
  2. Tipos de Channel: Rendezvous, Buffered, Conflated y Unlimited
  3. Mutex y Semaphore para el estado compartido
  4. Actores y gestión estructurada del estado
← Volver a Kotlin Academy