0Pricing
Kotlin Academy · Ders

Channel Türleri: Rendezvous, Buffered, Conflated, Unlimited

İletişim biçiminiz için doğru kanal türünü seçin.

Channel Türleri: Rendezvous, Buffered, Conflated, Unlimited, CoddyKit'te ücretsiz bir Kotlin Academy dersidir. Bu, 4 dersinin 2. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Kotlin Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Kotlin Academy kursu toplamda 4 dersten oluşur.

Kanal Oluşturucu

Channel<T>(capacity) ile kanallar oluşturun. Kapasite, arabelleğe alma ve askıya alma davranışını belirler.

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

RENDEZVOUS Kanalı (capacity=0)

Varsayılan kanal. send, bir alıcı hazır olana kadar askıya alınır; receive ise bir gönderici gönderim yapana kadar askıya alınır. Birbirleriyle buluşurlar; aynı noktada karşılaşırlar.

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

Arabellekli Kanal

Arabellekli kanal, arabellek dolana kadar göndericinin beklemeden devam etmesine olanak tanır. Dolduğunda send askıya alınır.

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

Kanal.BUFFERED

Channel.BUFFERED, varsayılan kapasiteyi (64) kullanır. Bu, Channel(64) ile eşdeğerdir.

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

Sınırsız Kanal

Channel.UNLIMITED, göndericiyi hiçbir zaman askıya almaz; tüm değerleri arabelleğe alır. Dikkatli kullanın: belleğin sınırsız büyümesi mümkündür.

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

Birleştirilmiş Kanal

Channel.CONFLATED, yalnızca en güncel değeri korur. Önceki değer alınmadan yeni bir değer gelirse eski değer atılır.

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 ve BUFFERED Zamanlaması

RENDEZVOUS, üreticiyle tüketiciyi eşzamanlı hâle getirir. BUFFERED, üreticinin önden çalışmasına izin vererek zamanlamaları birbirinden ayırır.

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

onBufferOverflow Stratejisi

Channel(capacity, onBufferOverflow) ile arabellek dolduğunda ne olacağını seçin: SUSPEND (varsayılan), EN_ESKİYİ_AT veya EN_YENİYİ_AT.

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
}

Kanal Türünü Seçme

Karar kılavuzu: sıkı eşzamanlama için RENDEZVOUS; aktarım kapasitesi için BUFFERED; yalnızca en güncel değer için (kullanıcı arayüzü durumu gibi) CONFLATED; kaybın kabul edilemediği olay günlükleme işlemleri için UNLIMITED.

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

select İçinde Kanal

select, aynı anda birden çok kanalı beklemenize ve hazır olan ilk kanalı seçmenize olanak tanır.

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

Zamanlayıcı Kanalı

ticker(delay), her delay milisaniyede bir Unit üreten bir kanal oluşturur; tekrarlanan yoklamalar için kullanışlıdır.

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

Hızlı Kontrol

Yalnızca en güncel değeri hangi kanal türü korur?

Özet

RENDEZVOUS: eşzamanlı, arabellek yok. BUFFERED: zamanlamaları birbirinden ayırır. CONFLATED: yalnızca en güncel değeri korur, eskisini atar. UNLIMITED: göndericiyi hiçbir zaman askıya almaz. Seçiminizi veri kaybına toleransınıza ve aktarım kapasitesi gereksinimlerinize göre yapın.

Sıkça Sorulan Sorular

“Channel Türleri: Rendezvous, Buffered, Conflated, Unlimited” dersi ücretsiz mi?

Evet — “Channel Türleri: Rendezvous, Buffered, Conflated, Unlimited” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Kotlin Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Kotlin Academy kursu toplamda 4 dersten oluşur.

“Channel Türleri: Rendezvous, Buffered, Conflated, Unlimited” dersinde ne öğreneceğim?

İletişim biçiminiz için doğru kanal türünü seçin. Kotlin Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Kotlin Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Kotlin Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 2. dersidir.

“Channel Türleri: Rendezvous, Buffered, Conflated, Unlimited” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Kotlin Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Kotlin Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

  1. Channel Temelleri: send, receive ve close
  2. Channel Türleri: Rendezvous, Buffered, Conflated, Unlimited
  3. Paylaşılan Durum için Mutex ve Semaphore
  4. Actor'ler ve Yapılandırılmış Durum Yönetimi
← Kotlin Academy Sayfasına Dön