Channel: bu nima, kanal turlari va Kotlin-dagi korutinlar

Kotlin-da Channel nima?

Channel — kontseptual jihatdan Java-dagi BlockingQueue-ga o‘xshaydi, lekin bloklovchi put() va take() o‘rniga suspend-funksiyalar send() va receive() dan foydalanadi. Kotlin dasturchisi Channel-ni umumiy xotira orqali sinxronizatsiyasiz korutinlar o‘rtasida ma’lumot almashinuvini tashkil qilish uchun ishlatadi. Kanal tartibli yetkazib berishni kafolatlaydi — yuborish tartibi qabul qilish tartibi bilan mos keladi.

Kanal yaratish

Channel yaratish uchun fabrika funksiyasi Channel<T>(capacity) chaqiriladi. capacity parametri kanal turini belgilaydi: RENDEZVOUS (0), UNLIMITED (Int.MAX_VALUE), CONFLATED (-1) yoki aniq raqam. T elementi turi generik orqali belgilanadi. Kanalni close() orqali yopish yangi elementlar bo‘lmasligini bildiradi.

Send va Receive

send(value) — suspend-funksiya, kanal to‘la bo‘lsa yuboruvchi korutinani to‘xtatadi. receive() — suspend-funksiya, kanal bo‘sh bo‘lsa qabul qiluvchini to‘xtatadi. Muqobil trySend() va tryReceive() — bloklamaydigan versiyalar, operatsiya imkonsiz bo‘lganda Boolean yoki null qaytaradi. Ular suspend bo‘lmagan kontekstlarda foydali.

kotlinx.coroutines-dagi Channel turlari

Kotlin bufer sig‘imi orqali to‘rt xil Channel variantini taqdim etadi: Rendezvous (sig‘im 0), Buffered (sig‘im N), Conflated (sig‘im 1, qayta yozish) va Unlimited (sig‘im Int.MAX_VALUE). Har bir tur o‘z vazifasini hal qiladi, qat’iy sinxronizatsiyadan ommaviy ma’lumot buferlashgacha.

Rendezvous Channel — eng qat’iy: send() boshqa korutinada receive() chaqirilguncha bloklanadi. Aslida, bu ikki korutinaning uchrashish nuqtasidir. Qat’iy handshake uchun ideal, yuboruvchi element qabul qiluvchi tomonidan ishlanishini kutishi kerak. Ma’lumot yo‘qotilishi istisno qilinadi — send receive bajarilguncha tugallanmaydi.

Conflated Channel — faqat oxirgi yuborilgan qiymatni saqlaydi. Agar yuboruvchi qabul qiluvchi eskisini olmaguncha yangi element qo‘ygan bo‘lsa, eskisi tashlanadi. Conflated Channel UI holati uchun foydali: foydalanuvchi slayderni tez o‘zgartirsa, oraliq qiymatlar tashlanishi va faqat oxirgisi ishlanishi mumkin.

Kanallarda Producer-Consumer

Kanaldagi klassik Producer-Consumer namunasi parallel korutinlar orqali amalga oshiriladi. Producer sikl ichida send(value) chaqiradi, consumer — receive(value). Ishlab chiqaruvchi va iste’molchi turli Dispatchers-larda ishlashi mumkin: producer Dispatchers.IO-da, consumer Dispatchers.Main-da. Channel Lock va synchronized holda avtomatik ravishda kirishni sinxronlashtiradi.

Fan-out — bitta kanalda bir nechta iste’molchi. Har bir element aniq bitta iste’molchiga yetadi (round-robin taqsimoti). Fan-in — bir nechta ishlab chiqaruvchi bitta kanalga yozadi. Yuboruvchi korutinlar yuborish uchun raqobatlashadi, lekin elementlar tartibi saqlanadi. Ikkala stsenariy qo‘shimcha sinxronizatsiyani talab qilmaydi.

Produce — bu avtomatik yopilish bilan kanal yaratuvchi korutin quruvchisi. produce { } funksiyasi ReceiveChannel qaytaradi — iste’molchi uchun faqat o‘qish uchun kanal. Quruvchi ichida send() ma’lumot yuboradi va blok tugallanganda yoki istisno vaqtida kanal avtomatik yopiladi, oqishning oldini oladi.

Select va multipleksatsiya

kotlinx.coroutines kutubxonasi select — bir nechta alternativlardan birinchi tugallangan kanalni kutuvchi ifodani taqdim etadi. Select bir nechta kanalni multipleksatsiya qilishga imkon beradi: masalan, ikki manbadan ma’lumot kutish va birinchi javob berganini qayta ishlash. Sintaksis — select<T> { channel1.onReceive { } channel2.onReceive { } }. Bu Rx-dagi amb operatoriga alternativdir.

Channel kod namunalari

Birinchi misol — eng oddiy Rendezvous Channel, yuboruvchi qabulni kutadi:

val channel = Channel<String>()

scope.launch {
    channel.send("Hello")
    println("Yuborildi")
}

scope.launch {
    val msg = channel.receive()
    println("Qabul qilindi: $msg")
}

Ikkinchi misol — bitta kanalda bir nechta iste’molchi (fan-out):

val channel = Channel<Int>(Channel.UNLIMITED)

scope.launch {
    for (x in 1..10) channel.send(x)
    channel.close()
}

repeat(2) { id ->
    scope.launch {
        for (msg in channel) {
            println("Iste’molchi #$id: $msg")
        }
    }
}

Uchinchi misol — xato boshqaruvi bilan produce quruvchisidan foydalanish:

val source = produce {
    for (i in 1..5) {
        delay(200)
        send(i)
    }
}

scope.launch {
    source
        .consumeAsFlow()
        .catch { println("Xato: $it") }
        .collect { println("Element: $it") }
}

Channel vs Flow

Channel — hot primitiv: ma’lumotlar obunachilardan qat’iy nazar chiqariladi. Flow — sovuq: ma’lumotlar obuna vaqtida yaratiladi. Channel bir nechta ishlab chiqaruvchi va iste’molchini har bir elementning bitta iste’molchiga yetkazilishi kafolati bilan qo‘llab-quvvatlaydi (fan-out). Flow mustaqil ishlab chiqaruvchilar uchun mo‘ljallanmagan.

Channel backpressure boshqaruvi uchun sozlanishi bufer sig‘imi va suspend-funksiyalar send/receive dan foydalanadi. Flow korutinlar orqali avtomatik backpressure bilan suspend mexanizmi collect dan foydalanadi. Channel — maxsus stsenariylar uchun past darajali vosita: callback konvertatsiyasi, aktyor modeli, bir nechta yuboruvchi bilan vazifalar navbati.

Android-da kundalik stsenariylar uchun (UI holati, ma’lumotlar bazasidan reaktiv oqimlar) Google Flow-ni tavsiya qiladi, Channel-ni emas. Channel korutinlar o‘rtasida aniq bufer nazorati bilan hot ma’lumot almashinuvi kerak bo‘lganda yoki callback interfeyslarini callbackFlow orqali konvertatsiya qilishda ishlatilishi kerak, uning ichki tatbiqi Channel dan foydalanadi.

Muhim amaliy misol: WebSocket mijozini tatbiq qilishda, Channel bir korutindan xabar yozishga va boshqasidan o‘qishga imkon beradi, har bir xabar bir marta qayta ishlanishi kafolati bilan. Flow bu vazifa uchun mos emas, chunki sovuq va bir nechta ishlab chiqaruvchini qo‘llab-quvvatlamaydi. UNLIMITED sig‘imli Channel kiruvchi xabarlarning iste’molchining vaqtinchalik kechikishlarida yo‘qolmasligini ta’minlaydi.

Kanalning hayotiy tsikli boshqaruvi — Channel bilan ishning muhim qismi. Barcha ma’lumotlar yuborilgandan so‘ng kanal yopilishi kerak, iste’molchi iteratsiyani tugallashi uchun. channel.close() chaqiruvi yangi elementlar bo‘lmasligini bildiradi. Iste’molchi for (item in channel) orqali iteratsiya qilishi mumkin — sikl close() va bufer bo‘shatilgandan so‘ng avtomatik tugaydi. Shu bilan birga, iste’molchi ClosedReceiveChannelException boshqaruvi bilan sikl ichida receive() chaqirishi mumkin.

Channel Android-da bog‘liqliksiz EventBus tatbiqi uchun faol ishlatiladi: Broadcast strategiyasi bilan global Channel<Event> ilovaning istalgan nuqtasidan hodisalar yuborishga imkon beradi. LiveData-dagi shinadan farqli o‘laroq, Channel lifecycle-ga bog‘liq emas va ekranlar o‘rtasida o‘tishda nollashni talab qilmaydi. ViewModel-dan send() va Activity/Fragment-da lifecycleScope orqali receive() Event sinflarisiz tip-xavfsiz aloqani ta’minlaydi. Kanaldagi bir nechta iste’molchi yukni taqsimlaydi — har bir element bir marta qayta ishlanadi, bu turli obunachilarda bir hodisaning qayta ishlanishining takrorlanishini oldini oladi.

Aktyor tizimlarida Channel aktyor uchun xabar navbati bo‘lgan mailbox tatbiqi uchun asos bo‘lib xizmat qiladi. Aktyor — bu siklda Channel-dan xabarlarni o‘qiyotgan va ularni ketma-ket qayta ishlayotgan korutinadir. Bu yondashuv har bir xabarni yuborish tartibi bo‘yicha, ma’lumot poygalarisiz qayta ishlanishini kafolatlaydi. Kotlin-da Akka-dan farqli o‘laroq, o‘rnatilgan aktyor turi yo‘q, lekin Channel + launch engil o‘rnini bosuvchidir.

Ikki tomonlama almashinuv uchun kanal juftliklari ishlatiladi: bitta kanal mijozdan serverga so‘rovlar uchun, ikkinchisi — serverdan mijozga javoblar uchun. Masalan, ko‘p oqimli ilovada Pipe tatbiq qilishda: ishlab chiqaruvchi OutputChannel-ga yozadi, iste’molchi InputChannel-dan o‘qiydi. suspend-funksiyalar send va receive kafolatlaydiki, Producer-Consumer chaqiruvlar stekini to‘ldirmaydi, chunki korutinlar bloklanmaydi, balki to‘xtatiladi. BUFFERED sig‘imli Channel ishlab chiqaruvchi va iste’molchi tezliklari taxminan teng bo‘lgan ko‘pchilik stsenariylar uchun mos keladi. Asimmetrik stsenariylar uchun UNLIMITED dan foydalaning, ishlab chiqaruvchi iste’molchi band bo‘lganda to‘xtatilmasligi uchun — bu deadlock xavfini kamaytiradi, lekin xotira iste‘molini oshiradi.

Channel sig‘imini tanlash

Kanallarda arxitektura loyihalashtirilganda capacity haqida eslab qolish muhim: sig‘imni tanlash to‘g‘ridan-to‘g‘ri cho‘qqi yuk ostidagi harakatga ta’sir qiladi. BUFFERED(N) sig‘imli kanallar tekislovchi bufer kabi ishlaydi: agar iste’molchi vaqtincha ishlab chiqaruvchidan sekinroq bo‘lsa, elementlar to‘planadi. Agar iste’molchining o‘rtacha tezligi ishlab chiqaruvchidan barqaror past bo‘lsa, bufer to‘ladi va yuboruvchi korutinasi to‘xtatiladi — bu xotirani haddan tashqari yuklashdan himoya qiluvchi avtomatik backpressure.

Channel monitoringi va disk raskadrovkasi uchun kotlinx-coroutines-debug dan foydalaning: vosita faol korutinlar sonini, ularning kanallarining holatini (ochiq/yopiq, buferdagi elementlar soni) va to‘xtatilgan send/receive operatsiyalarining chaqiruvlar stekini ko‘rsatadi. Channel shuningdek qayd qiluvchi proksi bilan o‘ralishi mumkin: LoggingChannel<T> sinfi chaqiruvlarni haqiqiy Channel-ga delegatsiya qiladi, send, receive va close operatsiyalarini qayd qiladi. Bu close() chaqirilmaganda va iste’molchi korutinasi abadiy yangi elementlarni kutganda kanal oqishlarini aniqlashga yordam beradi.