Kotlin Academy · 강의

채널 타입: 랑데부, 버퍼링, 융합, 무제한

통신 패턴에 맞는 채널 타입을 선택해 보세요.

채널 타입: 랑데부, 버퍼링, 융합, 무제한은(는) CoddyKit의 무료 Kotlin Academy 강의입니다. 이것은 4개 중 2번째 강의입니다. 아래에서 전체 강의를 무료로 읽을 수 있으며, 내장 코드 에디터와 24/7 AI 튜터와 함께 브라우저에서 직접 실습할 수 있습니다. 이 강의는 Kotlin Academy 학습 경로의 일부이며, 진행 상황이 웹과 CoddyKit 앱에 동기화됩니다. Kotlin Academy 강의에는 총 4개의 강의가 포함되어 있습니다.

채널 생성기

Channel<T>(capacity)로 채널을 생성합니다. 용량에 따라 버퍼링 및 일시 중단 동작이 결정됩니다.

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

랑데부 채널(capacity=0)

기본 채널입니다. send는 수신자가 준비될 때까지 일시 중단되고, receive는 송신자가 보낼 때까지 일시 중단됩니다. 두 작업은 같은 지점에서 만나는 랑데부를 수행합니다.

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

버퍼 채널

버퍼 채널을 사용하면 버퍼가 가득 찰 때까지 송신자가 기다리지 않고 계속 실행할 수 있습니다. 버퍼가 가득 차면 send가 일시 중단됩니다.

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는 기본 용량(64)을 사용합니다. 이는 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()
}

무제한 채널

Channel.UNLIMITED는 송신자를 절대 일시 중단하지 않고 모든 값을 버퍼링합니다. 주의해서 사용하십시오. 메모리가 제한 없이 증가할 수 있습니다.

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

RENDEZVOUS와 BUFFERED의 타이밍

랑데부는 생산자와 소비자를 동기화합니다. 버퍼 채널은 생산자가 먼저 실행되도록 하여 타이밍을 분리합니다.

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 전략

Channel(capacity, onBufferOverflow)를 사용하면 버퍼가 가득 찼을 때의 동작을 선택할 수 있습니다. 기본값인 SUSPEND, 가장 오래된 항목 삭제 또는 최신 항목 삭제 중에서 선택하십시오.

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
}

채널 유형 선택하기

선택 가이드: 긴밀한 동기화에는 랑데부, 처리량 향상에는 버퍼 채널, 최신 값만 필요할 때(예: UI 상태)에는 결합 채널, 손실을 허용할 수 없는 이벤트 로그 기록에는 무제한 채널을 사용하십시오.

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에서 채널 사용하기

select를 사용하면 여러 채널을 동시에 기다리면서 먼저 준비된 채널을 선택할 수 있습니다.

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

틱커 채널

ticker(delay)는 delay밀리초마다 Unit을 방출하는 채널을 생성합니다. 반복적인 폴링에 유용합니다.

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

빠른 확인

가장 최근의 값만 유지하는 채널 유형은 무엇입니까?

복습

랑데부: 동기화되며 버퍼가 없습니다. Buffered: 타이밍을 분리합니다. Conflated: 최신 값만 유지하고 이전 값은 버립니다. Unlimited: 송신자를 절대 일시 중단하지 않습니다. 값 손실 허용 범위와 처리량 요구 사항에 따라 선택하십시오.

자주 묻는 질문