0Pricing
Kotlin Academy · Lezione

Tipi di Channel: Rendezvous, Buffered, Conflated, Unlimited

Scelga il tipo di channel più adatto al proprio modello di comunicazione.

Tipi di Channel: Rendezvous, Buffered, Conflated, Unlimited è una lezione Kotlin Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Kotlin Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Kotlin Academy include 4 lezioni in totale.

Factory dei canali

Crei i canali con Channel<T>(capacity). La capacità determina il comportamento del buffering e della sospensione.

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

Canale rendezvous (capacity=0)

È il canale predefinito. send sospende l'esecuzione finché un ricevitore non è pronto e receive sospende l'esecuzione finché un mittente non invia un valore. Si incontrano nello stesso punto, come in un rendezvous.

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

Canale con buffer

Un canale con buffer consente al mittente di continuare senza attendere finché il buffer non è pieno. Quando è pieno, send sospende l'esecuzione.

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 utilizza la capacità predefinita (64). È equivalente 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()
}

Canale illimitato

Channel.UNLIMITED non sospende mai il mittente: memorizza nel buffer tutti i valori. Lo utilizzi con cautela: la memoria potrebbe crescere senza limiti.

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

Canale conflated

Channel.CONFLATED conserva solo il valore più recente. Se arriva un nuovo valore prima che quello precedente venga ricevuto, il valore precedente viene scartato.

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

Tempistiche di RENDEZVOUS e BUFFERED

Rendezvous sincronizza produttore e consumatore. Buffered consente al produttore di procedere in anticipo, disaccoppiandone la tempistica.

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

Strategia onBufferOverflow

Con Channel(capacity, onBufferOverflow), scelga che cosa accade quando il buffer è pieno: SUSPEND (predefinito), DROP_OLDEST oppure 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
}

Scelta del tipo di canale

Guida alla scelta: Rendezvous per una sincronizzazione stretta; Buffered per il throughput; Conflated per mantenere solo il valore più recente (come nello stato dell'interfaccia); Unlimited per la registrazione degli eventi quando non è accettabile perderne alcuno.

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 in select

select consente di attendere contemporaneamente più canali, scegliendo il primo 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()
}

Canale ticker

ticker(delay) crea un canale che emette Unit ogni delay millisecondi: è utile per il polling ripetuto.

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

Controllo rapido

Quale tipo di canale conserva solo il valore più recente?

Riepilogo

Rendezvous: sincronizzato, senza buffer. Buffered: disaccoppia la tempistica. Conflated: conserva solo il valore più recente e scarta quelli precedenti. Unlimited: non sospende mai il mittente. Scelga in base alla tolleranza alla perdita di dati e alle esigenze di throughput.

Domande Frequenti

La lezione «Tipi di Channel: Rendezvous, Buffered, Conflated, Unlimited» è gratuita?

Sì — il testo completo di «Tipi di Channel: Rendezvous, Buffered, Conflated, Unlimited» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Kotlin Academy, passa a CoddyKit PRO. Il corso Kotlin Academy include 4 lezioni in totale.

Cosa imparerò in «Tipi di Channel: Rendezvous, Buffered, Conflated, Unlimited»?

Scelga il tipo di channel più adatto al proprio modello di comunicazione. Eserciti Kotlin Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Kotlin Academy?

Non è richiesta alcuna esperienza precedente. Kotlin Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Tipi di Channel: Rendezvous, Buffered, Conflated, Unlimited»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Kotlin Academy?

Sì. Ogni lezione Kotlin Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Basi dei Channel: send, receive e close
  2. Tipi di Channel: Rendezvous, Buffered, Conflated, Unlimited
  3. Mutex e Semaphore per lo stato condiviso
  4. Actor e gestione strutturata dello stato
← Torna a Kotlin Academy