
Bu metin, Kotlin Coroutines kitabının bir bölümüdür. Kitabın tamamına LeanPub üzerinden erişebilirsiniz
Flow kavramı, çoğu geliştiricinin sandığından çok daha basittir.Aslında yalnızca hangiişlemlerin yürütüleceğini tanımlayan bir yapıdır. Bir anlamda, askıya alınabilir (
suspending) bir lambda ifadesinebenzer, ancak bunun üzerine bazı ek unsurlar barındırır. Bu bölümde,
Flow arayüzünü (Flow interface) ve flowyapıcısını (
builder) nasıl uygulayabileceğinizi, bir lambda ifadesini adım adım dönüştürerek göstereceğim. Bu süreçsize
Flow’un nasıl çalıştığına dair derin bir kavrayış kazandıracaktır.Bu bölüm, kullandığı araçları gerçekten anlamakisteyen meraklı geliştiriciler için yazılmıştır. Eğer bu sizi tanımlamıyorsa, bu bölümü atlayabilirsiniz.Ancak okumaya
karar verirseniz, umarım keyif alırsınız.
çağrılabilir.
fun main() { // Parametre almayan ve değer döndürmeyen (Unit) bir lambda fonksiyonu tanımlanıyor // () -> Unit = parametresiz fonksiyon tipi, Unit dönüş tipini belirtir val f: () -> Unit = { // Lambda gövdesi içinde sırayla harfler yazdırılıyor print("A") print("B") print("C") } // Lambda fonksiyonu ilk kez çağrılıyor f() // ABC yazdırır // Lambda fonksiyonu ikinci kez çağrılıyor f() // ABC yazdırır // Çıktı: ABCABC (boşluk olmadan) // Her çağrıda aynı işlemler tekrarlandığı için aynı çıktıyı verir }
suspend yapalım ve içine bir miktar gecikme (delay)ekleyelim. Dikkat edilmesi gereken önemli bir nokta şudur: Bu tür bir askıya alınabilir (
suspending) lambda ifadesiher çağrıldığında işlemler sıralı (sequential) olarak yürütülür.Yani, önceki çağrı tamamlanmadan yeni bir çağrı
yapılmamalıdır.
import kotlinx.coroutines.delay // Ana fonksiyon, içinde askıya alınabilir (suspending) kod kullanabilmek için suspend olarak tanımlanmış suspend fun main() { // Parametre almayan ve değer döndürmeyen (Unit) bir askıya alınabilir lambda fonksiyonu tanımlanıyor // suspend () -> Unit tipi, fonksiyonun suspending olduğunu ve askıya alınabileceğini belirtir val f: suspend () -> Unit = { print("A") // A harfini yazdır delay(1000) // 1 saniye bekle (coroutine'i askıya alır, thread'i bloklamaz) print("B") // B harfini yazdır delay(1000) // 1 saniye daha bekle print("C") // C harfini yazdır } f() // Fonksiyonu ilk kez çağır ve tamamlanmasını bekle f() // Fonksiyonu ikinci kez çağır ve tamamlanmasını bekle } // Çıktı sıralaması ve zamanlama: // A // (1 saniye bekler) // B // (1 saniye bekler) // C // A // (1 saniye bekler) // B // (1 saniye bekler) // C // Not: delay fonksiyonu coroutine'i askıya alır ama thread'i bloklamaz. // Bu sayede uzun süren işlemler sırasında sistem kaynakları verimli kullanılır.
emit. So, whenyou call the lambda expression
f, you need to specify another lambda expression that will be used as emit.emit adını vereceğiz.Dolayısıyla,
f adlı lambda ifadesini çağırdığınızda, emit olarak kullanılacak başka bir lambda ifadesini debelirtmeniz gerekir.
suspend fun main() { val f: suspend ((String) -> Unit) -> Unit = { emit -> emit("A") emit("B") emit("C") } f { print(it) } // ABC f { print(it) } // ABC }
emit fonksiyonunun da askıya alınabilir (suspending) olması gerekir.Ancak bu durum, kullandığımızfonksiyon türünü oldukça karmaşık hale getiriyor. Bu karmaşıklığı azaltmak için,
emit adında soyut bir metoda sahipolan
FlowCollector adlı bir fonksiyonel arayüz (function interface) tanımlayacağız.Böylece fonksiyon türü yerine buarayüzü kullanabiliriz. Buradaki püf nokta şudur:Fonksiyonel arayüzler, lambda ifadeleri ile tanımlanabilir.Bu sayede,
f fonksiyonunun çağrılma biçimini değiştirmemize gerek kalmaz.import kotlin.* // Ana fonksiyon, içinde askıya alınabilir (suspending) kod kullanabilmek için suspend olarak tanımlanmış suspend fun main() { // Daha karmaşık bir lambda fonksiyonu tanımı: // - suspend keyword'ü ile askıya alınabilir bir fonksiyon // - ((String) -> Unit) -> Unit tipi şunu ifade eder: // * Parametre olarak bir fonksiyon alır (String -> Unit tipinde) // * Kendisi Unit döndürür (değer döndürmez) val f: suspend ((String) -> Unit) -> Unit = { emit -> // emit parametresi, kendisine verilen String'i işleyen bir fonksiyondur // emit fonksiyonunu "A" parametresiyle çağır emit("A") // emit fonksiyonunu "B" parametresiyle çağır emit("B") // emit fonksiyonunu "C" parametresiyle çağır emit("C") } // f fonksiyonunu çağırırken, emit parametresi olarak bir lambda veriyoruz // Bu lambda (it) parametresini (yani "A", "B", "C" string'lerini) yazdırır // ABC yazdırır (her string için print çağrılır) f { print(it) } // Aynı şekilde ikinci kez çağırıyoruz // ABC yazdırır f { print(it) } // Çıktı: ABCABC (boşluk olmadan) }
emit fonksiyonunu it.emit(...) şeklinde çağırmak pratik değildir.Bunun yerine, FlowCollector arayüzünü bir alıcı (receiver) haline getireceğiz. Bu sayede, lambda ifadesi içinde
FlowCollector türünden bir alıcı (this)bulunmuş olur.Böylece
this.emit(...) veya doğrudan emit(...)şeklinde çağrıda bulunabiliriz. Önemli olan şu ki, budeğişiklik
f fonksiyonunun çağrılma biçimini etkilemez — f'yi aynı şekilde çağırmaya devam ederiz.import kotlin.* // Bir functional interface tanımlanıyor: // - FlowCollector adında bir interface // - Bu interface, yalnızca bir abstract metot içeriyor, dolayısıyla functional interface olarak işaretlenmiş // - emit fonksiyonu askıya alınabilir (suspend) ve bir String parametresi alıyor fun interface FlowCollector { suspend fun emit(value: String) } // Ana fonksiyon askıya alınabilir (suspend keyword'ü var) suspend fun main() { // f adında bir suspending extension fonksiyon tanımlanıyor: // - FlowCollector tipinde bir alıcı (receiver) üzerinden kullanılabilir // - Unit döner, yani hiçbir değer döndürmez val f: suspend FlowCollector.() -> Unit = { // emit fonksiyonu çağrılarak değerler yayımlanır (FlowCollector üzerinden) emit("A") // "A" değeri yayımlanır emit("B") // "B" değeri yayımlanır emit("C") // "C" değeri yayımlanır } // f fonksiyonunun ilk çağrısı yapılıyor: // - FlowCollector bir lambda ile implement ediliyor // - emit fonksiyon çağrısında alınan değer, it parametresi olarak bu lambda içinde kullanılıyor f { print(it) } // "it" parametresiyle "A", "B", "C" yazdırılır (çıkış: ABC) // f fonksiyonunun ikinci çağrısı yapılıyor: // - Aynı şekilde FlowCollector bir lambda ile implement ediliyor // - Yine "A", "B", "C" değerleri yazdırılır f { print(it) } // Çıkış: ABC // Toplam çıktı: ABCABC (boşluk olmadan yazdırılmış) }
arayüze
Flow adını vereceğiz ve tanımımızı bir nesne ifadesi (object expression) ile sarmalayacağız.import kotlin.* // FlowCollector adında bir functional interface tanımlanıyor: // - Bir tane abstract metot (emit) içeriyor // - emit, askıya alınabilir bir fonksiyon ve bir String parametresi alıyor fun interface FlowCollector { suspend fun emit(value: String) } // Flow adında bir interface tanımlanıyor: // - collect adında, askıya alınabilir (suspend) bir metot içeriyor // - collect metodu, bir FlowCollector parametresi kabul ediyor interface Flow { suspend fun collect(collector: FlowCollector) } // Ana programın başladığı yer // - Ana fonksiyon askıya alınabilir işlemler içeriyor (suspend ile işaretlenmiş) suspend fun main() { // builder adında bir suspending extension fonksiyon tanımlanıyor: // - FlowCollector türünde bir alıcı (receiver) üzerinde çalışıyor // - emit çağrılarıyla değerler yayımlanıyor (FlowCollector'dan) val builder: suspend FlowCollector.() -> Unit = { emit("A") // "A" değeri yayımlanır emit("B") // "B" değeri yayımlanır emit("C") // "C" değeri yayımlanır } // flow adında bir Flow nesnesi oluşturuluyor: // - collect metodunu override eden bir anonim sınıf kullanılıyor val flow: Flow = object : Flow { override suspend fun collect( collector: FlowCollector // collect metodu bir FlowCollector bekliyor ) { // FlowCollector içinde builder fonksiyonu çağrılıyor // - Burası FlowCollector tarafından yayımlanacak değerleri tanımlar collector.builder() } } // İlk collect çağrısı yapılıyor: // - Flow.collect çağrılır ve emit edilen değerler yazdırılır flow.collect { print(it) } // Çıktı: ABC (emit edilen değerler sırayla yazdırılır) // İkinci collect çağrısı yapılıyor: // - Aynı işlem tekrarlanır, böylece tekrar "ABC" yazdırılır flow.collect { print(it) } // Çıktı: ABC // Toplam çıktı: ABCABC (boşluk olmadan yazdırılmıştır) } }
flow oluşturucu (builder) fonksiyonunu tanımlayarak Flow nesnesi oluşturmayı daha da sadeleştirelim.import kotlin.* // FlowCollector adında bir functional interface tanımlanıyor: // - Tek bir abstract metot (emit) içeriyor // - emit askıya alınabilir (suspend) bir fonksiyon ve bir String parametresi alıyor fun interface FlowCollector { suspend fun emit(value: String) } // Flow adında bir interface tanımlanıyor: // - collect adında, askıya alınabilir (suspend) bir metot içeriyor // - collect metodu, bir FlowCollector parametresi kabul ediyor interface Flow { suspend fun collect(collector: FlowCollector) } // flow adında bir fonksiyon tanımlanıyor: // - Bu fonksiyon, bir FlowCollector üzerinde çalışacak bir builder alır // - Yeni bir Flow nesnesi döndürür (anonim sınıf ile oluşturulmuş) fun flow( builder: suspend FlowCollector.() -> Unit // FlowCollector için bir builder ) = object : Flow { // Flow arayüzünün collect metodunu override eder override suspend fun collect(collector: FlowCollector) { // FlowCollector üzerine builder çağrılır collector.builder() } } // Ana programın başladığı yer suspend fun main() { // f adında bir Flow nesnesi oluşturuluyor: // - flow fonksiyonu, builder parametresi ile çağrılıyor val f: Flow = flow { emit("A") // Builder içinde "A" değeri yayımlanır emit("B") // "B" değeri yayımlanır emit("C") // "C" değeri yayımlanır } // İlk collect çağrısı yapılıyor: // - Flow.collect çağrılır ve emit edilen değerler yazdırılır f.collect { print(it) } // Çıktı: ABC (emit edilen değerler sırayla yazdırılır) // İkinci collect çağrısı yapılıyor: // - Aynı işlem tekrarlanır, böylece tekrar "ABC" yazdırılır f.collect { print(it) } // Çıktı: ABC // Toplam çıktı: ABCABC (boşluk olmadan yazdırılmıştır) }
String türünü genel bir tür parametresiyle (generic type parameter) değiştirmektir.Bu sayede, her türden değerin yayımlanmasına (emit) ve toplanmasına (collect) olanak tanımış oluruz.
import kotlin.* // FlowCollector adında bir fun interface tanımlanır // T türünde bir parametre alır ve emit adında askıya alınabilir (suspend) bir metod içerir fun interface FlowCollector<T> { suspend fun emit(value: T) } // Flow adında bir generic interface tanımlanır // T türünde bir parametre alır ve collect adında bir metod içerir interface Flow<T> { suspend fun collect(collector: FlowCollector<T>) } // flow adında bir generic fonksiyon tanımlanır // T türünde bir parametre kabul eder ve bir Flow<T> nesnesi döner fun <T> flow( builder: suspend FlowCollector<T>.() -> Unit // FlowCollector<T>'ye uygulanabilecek bir builder ) = object : Flow<T> { // Flow<T> arayüzünü uygulayan bir nesne oluşturulur override suspend fun collect( collector: FlowCollector<T> // collect metodu FlowCollector<T> nesnesi alır ) { collector.builder() // Gelen collector üzerinde builder işlemi yapılır } } // Programın ana fonksiyonu suspend fun main() { // Bir Flow<String> nesnesi oluşturulur // Emit metodu kullanılarak A, B, C değerleri yayımlanır val f: Flow<String> = flow { emit("A") emit("B") emit("C") } // İlk collect çağrısı yapılır; yayımlanan değerler yazdırılır f.collect { print(it) } // ABC // İkinci collect çağrısı yapılır; aynı değerler tekrar yayımlanır f.collect { print(it) } // ABC }
Flow, FlowCollector ve flow yapısı neredeyse tam olarak bu şekilde uygulanmıştır.collectfonksiyonunu çağırdığınızda,
flow builder içinde tanımlanan lambda ifadesi çalıştırılır.Bu ifade içinde emitçağrıldığında ise, bu çağrı
collect sırasında belirtilen lambda ifadesini çalıştırır.Flow yapısının çalışma mantığıtam olarak budur. Burada sunduğumuz builder, bir
flow oluşturmanın en temel yoludur.İlerleyen bölümlerde farklıbuilder'ları da öğreneceğiz, ancak bunlar da genellikle arka planda
flow yapısını kullanırlar.public fun <T> Iterator<T>.asFlow(): Flow<T> = flow { // Iterator<T> için asFlow fonksiyonu tanımlaması // Bu fonksiyon bir Flow<T> döner. Yani, Iterator'daki her bir eleman yayımlanır (emit edilir). forEach { value -> // Iterator'un her bir elemanında forEach bloğu çalışır. // forEach ile her bir eleman `value` değişkenine atanır ve işlem yapılır. emit(value) // Her eleman emit metodu ile FlowCollector'a gönderilir ve akışa yayımlanır. } // Sonuç olarak, Iterator'u bir akışa (Flow) dönüştürür. } public fun <T> Sequence<T>.asFlow(): Flow<T> = flow { // Sequence<T> için asFlow fonksiyonu tanımlaması // Sequence'leri Flow<T>'ye dönüştürmek için kullanılır. Sequence, lazy evaluation uygulayan bir veri yapısıdır. forEach { value -> // Sequence'deki her bir eleman forEach bloğu içinden geçer. // Sequence elemanları birer birer `value` değişkenine atanır. emit(value) // Emit metodu, mevcut elemanı akışa ekler. } // Sonuç olarak, bir Sequence'i bir Flow olarak kullanma imkanı sağlanır. } public fun <T> flowOf(vararg elements: T): Flow<T> = flow { // flowOf adında bir fonksiyon tanımlaması // Bir vararg parametre alır ve bu parametreleri bir Flow<T> olarak döner. for (element in elements) { // Parametrelerden gelen her element üzerinde işlem yapılır. // for döngüsü ile vararg içindeki tüm elemanlara tek tek erişilir. emit(element) // Her bir eleman, akışın bir parçası olarak yayımlanır (emit edilir). } // Bu, değişken sayıda argümanın bir Flow<T>'ye dönüştürülmesini mümkün kılar. }
Flow, alıcı (receiver) ile tanımlanmış askıya alınabilir (suspending) lambda ifadelerine kıyasla biraz daha karmaşıkolarak düşünülebilir.Ancak asıl gücü, oluşturma, işleme ve gözlemleme işlemleri için tanımlanmış olan tüm bu
fonksiyonlarda yatar. Aslında bu fonksiyonların çoğu, perde arkasında oldukça basit çalışır.İlerleyen bölümlerde bunları
detaylı olarak inceleyeceğiz, ancak şimdilik şu sezgiyi edinmeni istiyorum:Bu fonksiyonların büyük çoğunluğu
flow,collect ve emit kullanılarak kolayca oluşturulabilir.flow içerisindeki her öğeyi dönüştüren map fonksiyonunu ele alalım: Bu fonksiyon yeni bir flowoluşturur, dolayısıyla
flow builder’ını kullanır.Oluşturulan flow çalıştırıldığında, sarmaladığı (wrap ettiği)asıl
flow da başlatılmalıdır.Bu nedenle map, builder bloğu içinde collect çağrısı yapar. Her bir öğe alındığında (collect içinde), map bu öğeyi dönüştürür ve ardından yeni flow’a emit ile aktarır.import kotlinx.coroutines.* import kotlinx.coroutines.flow.* // Flow'un map fonksiyonunun tanımlaması. fun <T, R> Flow<T>.map( // T tipindeki bir elemanı R tipine dönüştürmek için kullanılacak dönüşüm fonksiyonu. transformation: suspend (T) -> R ): Flow<R> = flow { // Bir Flow<R> başlatılır. collect { // Orijinal Flow'dan elemanlar toplanır. emit(transformation(it)) // Eleman `transformation` fonksiyonuyla işlenir ve yeni Flow'da yayımlanır (emit edilir). } } suspend fun main() { // flowOf fonksiyonu kullanılarak bir Flow<String> oluşturulur. flowOf("A", "B", "C") .map { // Her bir elemanı işlerken 1 saniyelik gecikme eklenir. delay(1000) // Eleman küçük harfe dönüştürülür. it.lowercase() } .collect { // Sonuçlar toplanır ve ekrana yazdırılır. println(it) } // (1 saniye) a // (1 saniye) b // (1 saniye) c }
önemlidir; çünkü bu sayede yalnızca yazdığımız kodun nasıl çalıştığını daha iyi kavramakla kalmayız, aynı zamanda benzer
işlevleri nasıl yazabileceğimizi de öğrenmiş oluruz.
fun <T> Flow<T>.filter( predicate: suspend (T) -> Boolean ): Flow<T> = flow { // `filter` fonksiyonu, bir akışın (Flow) içindeki elemanları bir koşula (predicate) göre süzmek için kullanılır. // Koşulu sağlayan elemanlar yeni bir akışta kullanıma sunulur. collect { // Orijinal Flow'daki elemanlar sırayla toplanır. if (predicate(it)) { // Eğer eleman koşulu sağlıyorsa... emit(it) // Eleman yayımlanır (emit edilir). } } } fun <T> Flow<T>.onEach( action: suspend (T) -> Unit ): Flow<T> = flow { // `onEach` fonksiyonu, bir akışın her elemanı üzerinde bir yan etki oluşturmak için kullanılır. // Elemanlar üzerinde belirtilen işlem (action) yapılır, ardından orijinal elemanlar yayımlanmaya devam eder. collect { // Orijinal Flow'daki elemanlar sırayla toplanır. action(it) // Her eleman için verilen işlem (action) gerçekleştirilir. emit(it) // İşlem tamamlandıktan sonra eleman tekrar yayımlanır (emit edilir). } } fun <T> Flow<T>.onStart( action: suspend () -> Unit ): Flow<T> = flow { // `onStart` fonksiyonu, bir akış başlatılmadan önce bir işlem (action) gerçekleştirmek için kullanılır. // Bu işlem, akış içindeki elemanlar toplanmadan önce bir defa çalıştırılır. action() // Akışın başında belirlenen işlem (action) gerçekleştirilir. collect { // Orijinal Flow'daki elemanlar sırayla toplanır. emit(it) // Toplanan elemanlar yayımlanır (emit edilir). } }
Flow, tıpkı askıya alınabilir (suspending) fonksiyonlar gibi doğası gereği eşzamanlı (synchronous) çalışır. Yanicollect çağrısı, akış (flow) tamamlanana kadar askıya alınmış şekilde bekler. Bu durum, Flow'un kendisininyeni bir coroutine başlatmadığı anlamına gelir.Akış içindeki belirli adımlar yeni coroutine’ler başlatabilir (tıpkı
suspend fonksiyonlarda olduğu gibi),ancak bu varsayılan bir davranış değildir. Çoğu Flow işleme adımı (örneğinmap, filter, onEach) eşzamanlı şekilde çalışır.Bu nedenle, onEach bloğu içinde bir delay çağrısı yapılırsa, bugecikme her öğe arasında gerçekleşir —tüm öğelerden önce değil.
import kotlinx.coroutines.* import kotlinx.coroutines.flow.* suspend fun main() { // flowOf, bir Flow oluşturur ve sırasıyla "A", "B", "C" elemanlarını içerir. flowOf("A", "B", "C") // onEach, her bir eleman işlenmeden önce bir işlem yapar. Burada her eleman için 1 saniyelik gecikme eklenir. .onEach { delay(1000) } // collect, Flow'dan yayımlanan elemanları toplar. Her elemanı alır ve println ile ekrana yazdırır. .collect { println(it) } } // (1 sec) // A // (1 sec) // B // (1 sec) // C
buffer veya conflate gibi fonksiyonlarla değiştirilebilir.Bu fonksiyonlar, akışınyukarısındaki işlemler için yeni bir coroutine başlatır.Benzer şekilde,
channelFlow gibi coroutine oluşturucular (builder) da gövdesi için yeni bir coroutine başlatır.Ancak unutulmamalıdır ki, varsayılan davranış eşzamanlıdır (
synchronous).
gerektiğini bilmek önemlidir.Bu bölümde en önemli kullanım durumlarını inceleyeceğiz.
Flow işleme fonksiyonları geliştirirken, akış içerisinde senkronizasyon mekanizmasıkullanmadan değiştirilebilir (mutable) durumlar tanımlayabilirsiniz.Çünkü
Flow adımları doğası gereği eşzamanlı (synchronous) olarak çalışır.
fun <T, K> Flow<T>.distinctBy( // Bu parametre, her elemandan benzersiz bir anahtar oluşturan bir fonksiyondur. keySelector: (T) -> K // Örneğin, bir veri sınıfında belirli bir alanı seçmek için kullanılabilir. ) = flow { // Yeni bir Flow oluşturuyoruz. Bu Flow, verilen orijinal akışın (Flow) elemanlarını filtreleyerek // benzersiz anahtarlara sahip olan elemanları yayımlayacak. val sentKeys = mutableSetOf<K>() // Benzersiz anahtarları saklamak için bir "Set" (küme) oluşturuyoruz. Sets, aynı anahtarı birden fazla kez saklamaz. // Burada daha önce işlenen anahtarlar depolanır. collect { value -> // Orijinal Flow'a ait tüm elemanlar sırayla alınır. Akışın elemanları, "value" değişkenine atanır. val key = keySelector(value) // Bu elemandan benzersiz bir anahtar elde etmek için "keySelector" fonksiyonu çağrılır. // Örneğin, bir nesne içindeki "id" alanını seçebilir. if (key !in sentKeys) { // Eğer bu anahtar daha önce işlenmemişse, yani Set'te bulunmuyorsa... sentKeys.add(key) // Anahtarı Set'e ekle (işlenmiş anahtarlar arasına ekle). emit(value) // Anahtar benzersiz olduğundan, bu eleman yayılır (emit edilir). Akışın tüketicisi bu değeri alabilir. } // Eğer anahtar daha önce işlenmişse, "emit" işlemi yapılmaz ve eleman atlanır. } // Bu işlem, akıştaki her bir eleman için tekrarlanır; böylece yalnızca benzersiz anahtarlarla eşleşen elemanlar yayımlanır. }
flow adımı içinde kullanılan ve tutarlı sonuçlar üreten bir örnek yer almaktadır:counter değişkeni her zaman doğru şekilde 1000'e kadar artırılır.import kotlinx.coroutines.* import kotlinx.coroutines.flow.* import kotlin.random.Random fun Flow<*>.counter() = flow<Int> { // Bu bir Extension Function'dır ve herhangi bir Flow türüne uygulanabilir. // Akıştaki her elemanı saymak için bir Flow oluşturur ve akışın her elemanına karşılık gelen sayacı yayımlar. var counter = 0 // Elemanları saymak için bir sayaç oluşturulur, başlangıç değeri 0'dır. collect { // Flow'un her bir elemanı sırasıyla işlenir. counter++ // Sayaç her elemanda 1 artırılır. // Sadece işlem yükü eklemek için boş bir işlem yapılır: List(100) { Random.nextLong() }.shuffled().sorted() // 100 rastgele uzun değer oluşturulur, karıştırılır ve sıralanır. // Bu işlem, akışı yapay olarak yavaşlatmak için eklenmiş. emit(counter) // Mevcut sayaç değeri yayımlanır (emit edilir). // Akışın tüketicisi, bu sayaç değerini alır. } } suspend fun main(): Unit = coroutineScope { // coroutineScope: Eş zamanlı iş parçacıkları (coroutine'ler) çalıştırır ve hepsi tamamlanana kadar bekler. val f1 = List(1000) { "$it" }.asFlow() // "f1", 0'dan 999'a kadar olan sayıları içeren bir Flow oluşturur. val f2 = List(1000) { "$it" }.asFlow() .counter() // "f2", 0'dan 999'a kadar olan sayıları içeren bir Flow oluşturur ve ardından "counter" fonksiyonuna uygulanır. // Bu akış, sayaç değerlerini yayımlar. launch { println(f1.counter().last()) } // Paralel bir coroutine başlatır. // "f1.counter()" çağrılır, her eleman sayılıp yayımlanır, sonra son elemandaki sayaç değeri (1000) ekrana yazdırılır. launch { println(f1.counter().last()) } // Yine 0-999 elemanlarının "counter()" ile sayılıp, son sayaç değeri (1000) yazdırılır. launch { println(f2.last()) } // "f2" akışı doğrudan kullanılır. Akış zaten "counter" uygulanmış şekilde, bu nedenle son elemanın yayımladığı değer (1000) yazdırılır. launch { println(f2.last()) } // Yukarıdaki ile aynı işlem yeniden yapılır ve yine 1000 değeri ekrana yazdırılır. }
flow) adımı içindeki bir değişkenin dışarıya çıkarılıp bir fonksiyon içine alınması yaygın bir hatadır.Bu türbir değişken, aynı
flow üzerinden veri toplayan (collect eden) tüm coroutine'ler arasında paylaşılan hâle gelir.Bu durumda, değişkenin kullanımı için senkronizasyon (synchronization) gereklidir ve bu durum akışa özgüdür (
flow-specific), ancak veri toplama işlemlerine özgü (flow-collection-specific) değildir. Bu nedenle,
f2.last()ifadesi yaklaşık 2000 döndürür, 1000 değil — çünkü bu değer, aynı
flow'un iki paralel yürütmesindüretilenöğelerin toplam sayısını yansıtır.
import kotlinx.coroutines.* import kotlinx.coroutines.flow.* import kotlin.random.Random fun Flow<*>.counter(): Flow<Int> { // Flow'un elemanlarını sayan bir fonksiyon. var counter = 0 // Sayaç, her eleman işlendiğinde bir artırılır ve bu değeri yayımlar. return this.map { // Akışı, her eleman üzerinde işlem yaparak dönüştürüyoruz. counter++ // Sayaç her eleman işlendiğinde bir artırılır. // Akışı yapay olarak yavaşlatmak için eklenmiş bir boş işlem: List(100) { Random.nextLong() }.shuffled().sorted() counter // Her elemanda sayaç değeri döndürülür. } } suspend fun main(): Unit = coroutineScope { // coroutineScope içinde ayrı coroutine'ler çalıştıracağız. val f1 = List(1_000) { "$it" }.asFlow() // 0'dan 999'a kadar olan sayıları içeren bir Flow oluşturuyoruz. val f2 = List(1_000) { "$it" }.asFlow() .counter() // f2 akışı, sayaç fonksiyonuna uygulanmış halde. Her eleman işlendiğinde, sayaç değeri yayımlanacak. // Paralel olarak dört farklı coroutine çalıştırıyoruz: launch { println(f1.counter().last()) } // f1 üzerinden çalıştırdığımız sayaç, 0'dan 999'a kadar elemanları işler ve sayaç değeri 1000 olarak sonlanır. launch { println(f1.counter().last()) } // Yukarıdaki aynı işlem yeniden yapılır, yine sayaç değeri 1000 olarak yazdırılır. launch { println(f2.last()) } // Burada f2 zaten bir sayaca bağlanmıştı. Çakışan coroutine'ler nedeniyle sayaç değerini // artıran işlemler birbirine karışabilir ve bu yüzden elde edilen değer 2000'den küçük olabilir. launch { println(f2.last()) } // Yukarıdaki ile aynı işlem yeniden yapılır ve yine "2000'den küçük" bir değer elde edilir. }
suspending) fonksiyonlar senkronizasyon (synchronization) gerektiriyorsa, bir
Flow içinde kullanılan bir değişken de — eğer bir fonksiyonun dışında, birsınıfın içinde ya da üst düzeyde (top-level) tanımlanmışsa — senkronizasyon gerektirir.
import kotlinx.coroutines.* import kotlinx.coroutines.flow.* import kotlin.random.Random var counter = 0 // Tüm kod boyunca paylaşılan global bir sayaç. Her coroutine, bu değişkeni paylaşır ve işlem sırasında birbirini etkileyebilir. fun Flow<*>.counter(): Flow<Int> = this.map { // Flow üzerindeki her eleman için işlemler gerçekleştiriyoruz: counter++ // Global "counter" değişkenini her elemanda bir artırıyoruz. // İşlemi yavaşlatmak ve yapay yük eklemek için sade bir görev yapıyoruz: List(100) { Random.nextLong() }.shuffled().sorted() counter // Arttırılmış olan sayaç değeri dönüş çıktısı olarak sağlanır. } suspend fun main(): Unit = coroutineScope { // coroutineScope ile eş zamanlı olarak birden fazla coroutine başlatıyoruz. val f1 = List(1_000) { "$it" }.asFlow() // 0'dan 999'a kadar olan sayıları içeren bir akış (Flow). val f2 = List(1_000) { "$it" }.asFlow() .counter() // f2 akışına önceden "counter" işlemi uygulanmış, her eleman üzerinden geçerken counter artırılır. // Aşağıda akış işleme için dört coroutine (iş parçacığı) başlatıyoruz: launch { println(f1.counter().last()) } // `f1.counter()` her çağrıldığında global "counter" ilk halinden itibaren işlem yapar. // Sayaç değeri, 1000 eleman işlendiğinde yaklaşık 1000 artar. Ancak, eş zamanlı çalışan diğer coroutine'ler nedeniyle daha fazla artmış olabilir. launch { println(f1.counter().last()) } // Yukarıdakiyle aynı iş yapılır. Ancak, yine global sayaç değeri diğer coroutine'ler nedeniyle etkilenebilir. launch { println(f2.last()) } // f2 üzerinde zaten `counter()` fonksiyonu çağrılmış durumdaydı. Elemanlar işlendikçe "counter" artırılacaktır. // Ancak global sayaç eş zamanlı çalışan diğer coroutine'ler nedeniyle zaten yüksek bir değere ulaşmış olabilir. launch { println(f2.last()) } // f2'nin aynı işlemi tekrarlanır. Diğer coroutine'ler global sayacı artırdığı için sonuç "4000'den küçük" olacak şekilde etkilenmiş olur. }
Flow, alıcı (receiver) ile tanımlanmış askıya alınabilir (suspending) bir lambda ifadesine kıyasla biraz dahakarmaşık olarak görülebilir.Ancak
Flow üzerinde uygulanan işleme (processing) fonksiyonları, temelde yalnızca ona yeniişlemler ekleyerek onu süsleyen yapılardır (decorator). Burada herhangi bir sihir (magic) yoktur:
Flow’un ve çoğuFlow yönteminin nasıl tanımlandığı aslında oldukça basit ve doğrudandır.