PricingLoginStart free
Kotlin Academy · Pelajaran

Dasar Channel: send, receive, dan close

Buat channel, kirim dan terima nilai, lalu tutup dengan benar.

Pelajaran 1 dari 413 langkah

Dasar Channel: send, receive, dan close adalah pelajaran Kotlin Academy gratis di CoddyKit. Ini adalah pelajaran 1 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.

Apa Itu Kanal?

Channel adalah primitif coroutine untuk berkomunikasi antarcoroutine — seperti antrean yang memblokir, tetapi ditangguhkan. Anggaplah ini sebagai pipa: satu sisi mengirim, sisi lainnya menerima.

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 dan receive

send(value) ditangguhkan sampai penerima siap. receive() ditangguhkan sampai sebuah nilai tersedia.

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

Menutup Kanal

channel.close() menandakan bahwa tidak ada lagi nilai yang akan dikirim. Penerima mendapatkan nilai yang masih tersangga, lalu perulangan berakhir.

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

Periksa status kanal dengan isClosedForSend, yang berarti tidak ada pengiriman lagi yang diizinkan, dan isClosedForReceive, yang berarti semua nilai telah dikonsumsi.

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

Pembuat produce

produce { } adalah pembuat coroutine yang membuat coroutine produsen dan mengembalikan ReceiveChannel. Kanal ditutup secara otomatis saat blok berakhir.

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
}

Ekstensi consumeEach

consumeEach { } melakukan iterasi pada kanal dan membatalkannya jika blok menimbulkan pengecualian, sehingga mencegah kebocoran.

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 dan trySend

Alternatif yang tidak menangguhkan: trySend / tryReceive segera mengembalikan ChannelResult tanpa menangguhkan.

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

Percabangan Keluar: Banyak Konsumen

Beberapa coroutine dapat menerima dari kanal yang sama dan membagi pekerjaan — ini adalah pola percabangan keluar.

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

Penggabungan Masuk: Banyak Produsen

Beberapa coroutine dapat mengirim ke kanal yang sama dan menggabungkan keluarannya — ini adalah pola penggabungan masuk.

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

Pola Alur Pemrosesan

Rangkai kanal menjadi alur pemrosesan, dengan setiap tahap membaca dari satu kanal dan menulis ke kanal lainnya — sangat baik untuk alur kerja pemrosesan data.

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

Kanal vs Alur

Kanal bersifat panas dan memiliki status — kanal tetap ada secara independen dari konsumsi. Alur bersifat dingin dan deklaratif — alur dimulai ulang pada setiap pengumpulan. Utamakan Flow untuk aliran data; gunakan Kanal untuk komunikasi produsen-konsumen.

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

Pemeriksaan Singkat

Apa yang terjadi saat Anda memanggil channel.close()?

Jawab di pelajaran interaktif

Ringkasan

send dan receive ditangguhkan hingga sisi lainnya siap. close() menandakan penyelesaian. Gunakan produce untuk produsen yang menutup dirinya sendiri, consumeEach untuk iterasi yang aman, dan kanal untuk pola percabangan keluar/penggabungan masuk.

Gratis untuk memulai

Belajar Kotlin dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus
51
Pelajaran
203
Mulai belajar gratisLihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Dasar Channel: send, receive, dan close” gratis?

Ya — teks lengkap “Dasar Channel: send, receive, dan close” 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 “Dasar Channel: send, receive, dan close”?

Buat channel, kirim dan terima nilai, lalu tutup dengan benar. 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 1 dari 4.

Berapa lama pelajaran “Dasar Channel: send, receive, dan close” 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