PricingLoginStart free
Kotlin Academy · Ders

flowOn ve buffer: Bağlam ve Geri Basınç

flowOn ile emisyon bağlamını değiştirin ve geri basınç için emisyonları buffer'layın.

4. ders / 413 adım

flowOn ve buffer: Bağlam ve Geri Basınç, CoddyKit'te ücretsiz bir Kotlin Academy dersidir. Bu, 4 dersinin 4. 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.

Akış Bağlamı

Varsayılan olarak bir akış, collect çağrısını yapan korutinin bağlamında çalışır. Siz değiştirmediğiniz sürece üreticinin ve tüketicinin dağıtıcısı aynıdır.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    flow {
        println("emit on: ${Thread.currentThread().name}")
        emit(1)
    }.collect {
        println("collect on: ${Thread.currentThread().name}")
    }
}

flowOn Üst Akış Bağlamını Değiştirir

flowOn(dispatcher), üst akışı (zincirde kendisinin üzerindeki her şeyi) belirtilen dağıtıcıda çalıştırırken toplama işlemi çağıranın dağıtıcısında kalır.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    flow {
        println("emit: ${Thread.currentThread().name}")
        emit(1)
    }.map {
        println("map: ${Thread.currentThread().name}")
        it * 2
    }.flowOn(Dispatchers.Default)  // above runs on Default
    .collect {
        println("collect: ${Thread.currentThread().name}")
    }
}

Bir Zincirde Birden Çok flowOn

flowOn öğesini birden çok kez kullanabilirsiniz. Her biri, önceki flowOn öğesine kadar doğrudan üzerindeki işleçleri etkiler.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    flow { emit(1) }
        .map { it + 1 }.flowOn(Dispatchers.IO)      // map runs on IO
        .map { it * 2 }.flowOn(Dispatchers.Default)  // this map runs on Default
        .collect { println("Result: $it") }           // collect on Main (runBlocking)
}

Geri Basınç Sorunu

Üretici, toplayıcının işleyebileceğinden daha hızlı değer ürettiğinde değerler kuyruğa girer. Arabellek olmadan bu durum üreticinin beklemesine neden olur.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    val time = System.currentTimeMillis()
    flow {
        repeat(3) { i ->
            delay(100)  // fast producer
            emit(i)
        }
    }.collect {
        delay(300)      // slow consumer
        println("Got $it in ${System.currentTimeMillis() - time}ms")
    }
}

buffer() İşleci

buffer(), üretici ve tüketiciyi ayrı korutinlerde eşzamanlı olarak çalıştırır ve üretilen değerleri bir kanalda arabelleğe alır. Üretici, tüketiciyi beklemez.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    val time = System.currentTimeMillis()
    flow {
        repeat(3) { i -> delay(100); emit(i) }
    }.buffer()  // producer and consumer run concurrently
    .collect {
        delay(300)
        println("Got $it in ${System.currentTimeMillis() - time}ms")
    }
}

buffer Kapasitesi

buffer(capacity), kanal arabelleğinin boyutunu belirler. Arabellek dolduğunda üretici askıya alınır (geri basınç). Varsayılan kapasite 64'tür.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
import kotlinx.coroutines.channels.Channel
fun main() = runBlocking {
    flow { repeat(5) { emit(it) } }
        .buffer(Channel.RENDEZVOUS)    // 0: producer waits
        // .buffer(Channel.BUFFERED)   // default: 64
        // .buffer(Channel.UNLIMITED)  // unbounded
        .collect { delay(50); println(it) }
}

Yalnızca En Güncel Değer için conflate()

conflate(), toplayıcı yavaş olduğunda ara değerleri atar ve yalnızca en son değer üretimini korur. Kullanıcı arayüzü durumu için kullanışlıdır.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    flow {
        repeat(5) { i -> emit(i); delay(50) }
    }.conflate()
    .collect { i ->
        delay(150)
        println("Collected: $i")  // skips some values
    }
}

Yavaş Toplayıcılar için collectLatest

collectLatest, yeni bir değer geldiğinde geçerli toplama bloğunu iptal eder ve en güncel değerle yeniden başlatır.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    flow {
        emit(1); delay(50)
        emit(2); delay(50)
        emit(3)
    }.collectLatest { value ->
        println("Processing $value")
        delay(100)  // gets cancelled if new value arrives
        println("Done $value")  // only prints for last value
    }
}

flowOn + buffer Örüntüsü

flowOn ile buffer öğelerini birleştirin: üreticiyi IO üzerinde (ağ/disk) çalıştırın, sonuçları arabelleğe alın ve Ana üzerinde toplayın.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun fetchItems(): Flow<String> = flow {
    repeat(3) { i ->
        delay(100)  // simulate IO
        emit("item-$i")
    }
}.flowOn(Dispatchers.IO).buffer(10)
fun main() = runBlocking {
    fetchItems().collect { println("UI: $it") }
}

Eşzamanlı Üreticiler için channelFlow

channelFlow, bir kanal tarafından desteklenen ve oluşturucu içinde birden çok korutinin eşzamanlı olarak değer üretmesine olanak tanıyan bir akış oluşturur.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun concurrentFlow(): Flow<Int> = channelFlow {
    launch { send(1) }
    launch { send(2) }
    launch { send(3) }
}
fun main() = runBlocking {
    concurrentFlow().collect { println(it) }
}

Doğru Stratejiyi Seçme

Özet: bağlam değiştirme için flowOn, aktarım kapasitesi için buffer, yalnızca en güncel değeri kullanan kullanıcı arayüzü için conflate, geçerliliğini yitirmiş işlemleri iptal etmek için collectLatest.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
// Guidelines:
// CPU-heavy production  -> flowOn(Dispatchers.Default)
// IO-heavy production   -> flowOn(Dispatchers.IO)
// Slow consumer         -> buffer()
// UI state updates      -> conflate() or StateFlow
// Search/autocomplete   -> collectLatest or flatMapLatest
fun main() = runBlocking { println("Choose the right strategy!") }

Hızlı Kontrol

flowOn, akış zincirinin hangi bölümünü etkiler?

İnteraktif derste cevapla

Özet

flowOn, üst akıştaki çalışmayı başka bir dağıtıcıya taşır. buffer, aktarım kapasitesini artırmak için üreticiyle tüketiciyi birbirinden ayırır. conflate, ara değerleri atar. collectLatest, yeni değerler geldiğinde yavaş işlemleri iptal eder.

Başlamak ücretsiz

Yapay zeka eğitmeniyle Kotlin öğren — ücretsiz

Tarayıcında gerçek kod yaz ve çalıştır, 7/24 yapay zeka eğitmeninden anında yardım al; web'de ya da uygulamada kaldığın yerden devam et.

Kurslar
51
Dersler
203
Ücretsiz öğrenmeye başlaTüm kursu görüntüle

Sıkça Sorulan Sorular

“flowOn ve buffer: Bağlam ve Geri Basınç” dersi ücretsiz mi?

Evet — “flowOn ve buffer: Bağlam ve Geri Basınç” 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.

“flowOn ve buffer: Bağlam ve Geri Basınç” dersinde ne öğreneceğim?

flowOn ile emisyon bağlamını değiştirin ve geri basınç için emisyonları buffer'layın. 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 4. dersidir.

“flowOn ve buffer: Bağlam ve Geri Basınç” 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. Flow İşleçleri: map, filter, transform ve take
  2. catch ve onCompletion: Flow'da Hata İşleme
  3. combine ve zip: Birden Çok Flow'u Birleştirme
  4. flowOn ve buffer: Bağlam ve Geri Basınç
← Kotlin Academy Sayfasına Dön