0Pricing
Kotlin Academy · Pelajaran

Tipe Channel: Rendezvous, Buffered, Conflated, Unlimited

Pilih tipe channel yang tepat untuk pola komunikasi Anda.

Tipe Channel: Rendezvous, Buffered, Conflated, Unlimited adalah pelajaran Kotlin Academy gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Kotlin Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Kotlin Academy mencakup 4 pelajaran total.

Pabrik Kanal

Buat kanal dengan Channel<T>(capacity). Kapasitas menentukan perilaku penyanggaan dan penangguhan.

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

Kanal RENDEZVOUS (capacity=0)

Kanal bawaan. send ditangguhkan sampai penerima siap, dan receive ditangguhkan sampai pengirim mengirim. Keduanya bertemu pada titik yang sama.

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

Kanal Berpenyangga

Kanal berpenyangga memungkinkan pengirim melanjutkan tanpa menunggu hingga penyangga penuh. Saat penuh, send ditangguhkan.

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 menggunakan kapasitas bawaan, yaitu 64. Ini setara dengan 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()
}

Kanal UNLIMITED

Channel.UNLIMITED tidak pernah menangguhkan pengirim — kanal ini menyangga semua nilai. Gunakan dengan hati-hati karena pertumbuhan penggunaan memori tidak terbatas dapat terjadi.

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

Kanal CONFLATED

Channel.CONFLATED hanya mempertahankan nilai terbaru. Jika nilai baru tiba sebelum nilai sebelumnya diterima, nilai lama dibuang.

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

Waktu RENDEZVOUS vs BUFFERED

RENDEZVOUS menyinkronkan produsen dan konsumen. Kanal berpenyangga memungkinkan produsen berjalan lebih dahulu sehingga waktu keduanya tidak saling bergantung.

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

Strategi onBufferOverflow

Dengan Channel(capacity, onBufferOverflow), pilih tindakan saat penyangga penuh: SUSPEND sebagai bawaan, DROP_OLDEST, atau 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
}

Memilih Jenis Kanal

Panduan keputusan: RENDEZVOUS untuk sinkronisasi ketat; kanal berpenyangga untuk laju pemrosesan; CONFLATED untuk nilai terbaru saja, seperti status antarmuka pengguna; dan UNLIMITED untuk pencatatan peristiwa ketika kehilangan data tidak dapat diterima.

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

Kanal dalam select

select memungkinkan Anda menunggu beberapa kanal secara bersamaan dan mengambil kanal pertama yang siap.

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

Kanal Pewaktu

ticker(delay) membuat kanal yang menghasilkan Unit setiap delay milidetik — berguna untuk pemeriksaan berulang.

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

Pemeriksaan Singkat

Jenis kanal mana yang hanya mempertahankan nilai terbaru?

Ringkasan

Pertemuan: tersinkronisasi, tanpa penyangga. Berpenyangga: memisahkan waktu produsen dan konsumen. Conflated: hanya menyimpan nilai terbaru dan membuang nilai lama. Unlimited: tidak pernah menangguhkan pengirim. Pilih berdasarkan toleransi kehilangan data dan kebutuhan laju pemrosesan Anda.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Tipe Channel: Rendezvous, Buffered, Conflated, Unlimited” gratis?

Ya — teks lengkap “Tipe Channel: Rendezvous, Buffered, Conflated, Unlimited” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Kotlin Academy, upgrade ke CoddyKit PRO. Kursus Kotlin Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Tipe Channel: Rendezvous, Buffered, Conflated, Unlimited”?

Pilih tipe channel yang tepat untuk pola komunikasi Anda. Kamu berlatih Kotlin Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Kotlin Academy?

Tidak diperlukan pengalaman sebelumnya. Kotlin Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “Tipe Channel: Rendezvous, Buffered, Conflated, Unlimited” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Kotlin Academy ini?

Ya. Setiap pelajaran Kotlin Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Dasar Channel: send, receive, dan close
  2. Tipe Channel: Rendezvous, Buffered, Conflated, Unlimited
  3. Mutex dan Semaphore untuk Status Bersama
  4. Actor dan Pengelolaan Status Terstruktur
← Kembali ke Kotlin Academy