
Bu metin, Kotlin Coroutines kitabının bir bölümüdür. Kitabın tamamına LeanPub üzerinden erişebilirsiniz
source (veri kaynağı) gibi yapıların yer aldığı Data/Adapters Layer (Veri/Adaptör Katmanı) üzerinden sunarak
başlayacağım.
Kotlin Coroutines desteği sunmaktadır.
suspending function (askıya alınabilir fonksiyon) desteğini kutudan çıktığı gibi (out-of-the-box) sunar. Yalnızca
fonksiyon tanımına
suspend anahtar kelimesini eklemek, ilgili isteği blocking (engelleyici) olmaktan çıkarıp askıyaalınabilir hale getirmek için yeterlidir.
// Retrofit ile tanımlanmış, harici bir HTTP API'sine erişim sağlayan arayüz. // Bu tür arayüzler, modern Android ve Kotlin projelerinde ağ // katmanını modüler ve kolay test edilebilir kılar. // Tüm fonksiyonlar askıya alınabilir (suspending) olarak tanımlanmıştır; // böylece IO işlemleri asenkron ve verimli yürütülür. class GithubApi { // Bu fonksiyon, belirli bir organizasyonun en fazla 100 adet GitHub deposunu (repo) çeker. // @GET anotasyonu, HTTP GET isteğinin yapılacağı endpoint'i tanımlar. // organization parametresi, yol (path) parametresi olarak endpoint'e dinamik şekilde eklenir. // Fonksiyon askıya alınabilir (suspend) olduğu için, // IO işlemi coroutine içerisinde bloklamadan yürütülür. // Dönen sonuç, her biri organizasyonun bir reposunu temsil eden // Repo nesnelerinden oluşan bir liste olarak döndürülür. @GET("orgs/{organization}/repos?per_page=100") suspend fun getOrganizationRepos( @Path("organization") organization: String ): List<Repo> }
kütüphanesidir. Room, fonksiyonları askıya alınabilir hale getirmek için
suspend anahtar sözcüğünü desteklediği gibi,tablo durumlarını gözlemlemek için
Flow kullanımını da destekler.// Room kütüphanesi ile tanımlanmış bir Data Access Object (DAO) arayüzü. // Bu arayüz, uygulamanın kalıcı veri katmanında (veritabanı) // konum (location) verilerinin yönetimini sağlar. // Modern yazılım mimarilerinde DAO, veri erişimini soyutlayarak kolay // test edilebilirlik ve sürdürülebilirlik sağlar. @Dao interface LocationDao { // Yeni bir konum nesnesini veritabanına ekler. // @Insert anotasyonu, Room'un ilgili SQL sorgusunu otomatik olarak üretmesini sağlar. // Askıya alınabilir (suspend) fonksiyon olduğundan, // veri tabanı işlemleri coroutines ile bloklamadan yürütülür. @Insert suspend fun insertLocation(location: Location) // Tüm konum kayıtlarını veritabanından siler. // @Query anotasyonu, doğrudan belirtilen SQL komutunun çalıştırılmasını sağlar. // Askıya alınabilir fonksiyon, işlemin uzun sürebilecek // veri tabanı işlemleriyle uyumlu çalışmasını garantiler. @Query("DELETE FROM location_table") suspend fun deleteLocations() // Veritabanındaki tüm konum kayıtlarını zamana göre sıralı biçimde gözlemler. // Dönüş türü Flow<List<Location>> olduğu için, // sonuçlar reaktif olarak dinlenebilir ve UI katmanı güncellemeleri anlık alabilir. // Modern reaktif mimarilerde, sürekli güncellenen veri setlerinin izlenmesi için önerilen yöntemdir. @Query("SELECT * FROM location_table ORDER BY time") fun observeLocations(): Flow<List<Location>> }
ile çalışmanız gerekiyorsa, bu fonksiyonları
suspendCancellableCoroutine kullanarak suspending function (askıyaalınabilir fonksiyon) hâline dönüştürebilirsiniz1Ayrıntılar için bkz. “Askıya Alma (Suspension) Mekanizması Nasıl Çalışır?” bölümü, “Bir Değer ile Devam Etme” alt başlığı..
Continuation üzerindeki resume metodu ile devam ettirilmelidir.invokeOnCancellation lambdaifadesi içinde ele alınmalıdır2Ayrıntılar için bkz. “İptal Mekanizması (Cancellation)” bölümü, “invokeOnCompletion” alt başlığı..
// Haber verisini almak için kullanılan askıya alınabilir (suspend) bir fonksiyon. // Geleneksel callback tabanlı bir API'yi, Kotlin Coroutines ile // uyumlu şekilde askıya alınabilir bir yapıya dönüştürür. // Bu desen, modern asenkron kodda "callback hell" ve karmaşıklığı azaltmak için kullanılır. suspend fun requestNews(): News { // suspendCancellableCoroutine, callback tabanlı işlemleri // coroutine ile entegre etmek için kullanılır. // Fonksiyon, haber verisi döndürülene kadar coroutine'i askıya alır. return suspendCancellableCoroutine<News> { cont -> // Haber API çağrısı başlatılır, sonuç geldiğinde callback tetiklenir. // requestNewsApi'nin, callback argümanı ile çalıştığı ve News nesnesi döndürdüğü varsayılır. val call = requestNewsApi { news -> // Haber verisi başarılı şekilde geldiğinde, coroutine kaldığı yerden devam eder. cont.resume(news) } // Coroutine dışarıdan iptal edilirse, bağlı olan ağ çağrısı da iptal edilmelidir. // invokeOnCancellation ile, iptal durumunda call.cancel() çağrılır. // Bu, gereksiz kaynak kullanımını önler ve ağ katmanında düzgün temizlik sağlar. cont.invokeOnCancellation { call.cancel() } } }
birkaç farklı şekilde uygulanabilir. Bu tür fonksiyonları sarmalayarak
Result dönebiliriz ve coroutine’i yaResult.success ile ya da Result.failure ile devam ettirebiliriz.// Haber API'sinden gelen yanıtı, hem başarı hem de hata durumunu kapsayan // Result<News> olarak döndüren askıya alınabilir fonksiyon. // Geleneksel callback tabanlı asenkron işlemler, Kotlin Coroutines ile uyumlu ve // iptal edilebilir bir biçime dönüştürülür. // Hatalar ve başarılar Result ile sarmalanır; böylece fonksiyonu kullanan kodun hata yönetimi basitleşir. suspend fun requestNews(): Result<News> { // suspendCancellableCoroutine, callback tabanlı API'lerin coroutine // tabanlı yapılarla entegrasyonu için kullanılır. // Coroutine, işlem tamamlanana kadar askıda kalır; iptal edilebilirlik desteklenir. return suspendCancellableCoroutine<Result<News>> { cont -> // Haber API çağrısı başlatılır; onSuccess ve onError callback'leri // ile başarı ve hata durumları yönetilir. // requestNewsApi'nin, iki ayrı callback (onSuccess ve onError) ile çalıştığı varsayılır. val call = requestNewsApi( onSuccess = { news -> // Başarılı bir haber yanıtı geldiğinde, coroutine devam ettirilir // ve Result.success ile döndürülür. cont.resume(Result.success(news)) }, onError = { e -> // Hata oluşursa, coroutine Result.failure ile hata içeren bir Result<News> döndürür. cont.resume(Result.failure(e)) } ) // Coroutine iptal edilirse, ilişkili ağ çağrısı da iptal edilir. // invokeOnCancellation, iptal sırasında ek temizlik işlemleri yapılmasına olanak tanır. cont.invokeOnCancellation { call.cancel() } } }
null değeriyle devam ettirilir.// Haber API'sinden veri çekmek için kullanılan, askıya alınabilir (suspend) // ve iptal edilebilir bir fonksiyon. // Geleneksel callback tabanlı asenkron işlemi, coroutine uyumlu, null dönebilen ve // hata durumunu sadeleştirilmiş şekilde yöneten bir yapıya dönüştürür. // Hata durumunda exception fırlatılmaz, doğrudan null dönülerek // üst katmanda basit hata yönetimi sağlanır. suspend fun requestNews(): News? { // suspendCancellableCoroutine, callback tabanlı asenkron işlemin // coroutine'lerle entegre edilmesini ve iptal edilebilirliği sağlar. return suspendCancellableCoroutine<News?> { cont -> // Haber API çağrısı başlatılır. Başarı ve hata durumları için iki farklı callback kullanılır. val call = requestNewsApi( onSuccess = { news -> // Başarılı bir haber yanıtı geldiğinde coroutine devam ettirilir, sonuç doğrudan döndürülür. cont.resume(news) }, onError = { e -> // Hata durumunda coroutine null değeriyle devam eder, exception fırlatılmaz. cont.resume(null) } ) // Coroutine dışarıdan iptal edilirse, ilişkili ağ çağrısı da iptal edilir. // invokeOnCancellation, gereksiz ağ kullanımı ve kaynak israfını önler. cont.invokeOnCancellation { call.cancel() } } }
devam ettirmek, hata durumunda ise bir istisna (exception) ile devam ettirmektir. Bu ikinci durumda, istisna askıya
alınan noktadan (suspension point) fırlatılır3Ayrıntılar için bkz. “Askıya Alma (Suspension) Mekanizması Nasıl Çalışır?” bölümü, “İstisna (Exception) ile Devam Ettirme (Resume)” alt başlığı..
// Haber API'sinden gelen yanıtı, başarı durumunda normal değer olarak, // hata durumunda ise exception olarak döndüren askıya alınabilir (suspend) fonksiyon. // Callback tabanlı bir API, coroutine ile uyumlu ve iptal edilebilir bir yapıya dönüştürülür. // Exception propagation, hata yönetiminin üst katmanda (çağıran fonksiyonda) yapılmasını sağlar. suspend fun requestNews(): News { // suspendCancellableCoroutine, callback tabanlı asenkron işlemleri coroutine ile entegre eder. // Fonksiyon, sonuç gelene veya hata oluşana kadar coroutine'i askıda tutar. return suspendCancellableCoroutine<News> { cont -> // Haber API çağrısı başlatılır; başarı ve hata durumları için ayrı callback'ler tanımlanır. val call = requestNewsApi( onSuccess = { news -> // Başarılı bir yanıt alındığında coroutine kaldığı yerden devam eder, sonuç doğrudan döndürülür. cont.resume(news) }, onError = { e -> // Hata oluşursa coroutine, exception fırlatılarak devam ettirilir. // Exception, üst katmanda try-catch ile yakalanabilir veya propagate edilebilir. cont.resumeWithException(e) } ) // Coroutine dışarıdan iptal edildiğinde, ilişkili ağ isteği de iptal edilir. // invokeOnCancellation, gereksiz kaynak kullanımını önler // ve sistem kaynaklarının verimli yönetimini sağlar. cont.invokeOnCancellation { call.cancel() } } }
gerektirmesidir. Blocking fonksiyonlar, sıradan suspending functions (askıya alınabilir fonksiyonlar) içinde asla
doğrudan çağrılmamalıdır. Kotlin Coroutines, thread (iş parçacığı) kullanımını büyük hassasiyetle yönetir ve bu
thread'leri engellemek ciddi bir sorundur. Android'de
Dispatchers.Main thread'i engellenirse, tüm uygulamanız donar.Dispatchers.Default engellenirse, işlemci verimliliğinden söz edilemez. Bu nedenle, dispatcher (yürütme bağlamı)belirtmeden blocking çağrı yapmak doğru değildir4Ayrıntılar için bkz. “İş Parçacığı Yöneticileri (Dispatchers)” bölümü..
withContext kullanılarak dispatcher açıkça belirtilmelidir.Uygulamalarda repository (depo) katmanı uygulanırken, çoğu durumda
Dispatchers.IO kullanmak yeterlidir5Ayrıntılar için bkz. “İş Parçacığı Yöneticileri (Dispatchers)” bölümü, “Giriş/Çıkış (GÇ/IO) Dağıtıcısı” alt başlığı..// Disk tabanlı kayıt verisinin okunması için tasarlanmış repository (depo) sınıfı. // Bu sınıf, veri okuma işini soyutlayarak, test edilebilirlik ve sürdürülebilirlik sağlar. // Temel amaç: disk erişimini güvenli, performanslı ve ana thread'den izole şekilde gerçekleştirmek. class DiscSaveRepository( private val discReader: DiscReader // Disk okuma işini üstlenen soyut servis/kütüphane ) : SaveRepository { // SaveRepository arayüzünü (contract) uygular // Kayıt verisini yükleyen askıya alınabilir (suspend) fonksiyon. // Bu fonksiyon, potansiyel olarak uzun sürebilecek engelleyici (blocking) I/O işlemini başlatır. override suspend fun loadSave(name: String): SaveData = // I/O işlemleri için özel olarak tasarlanmış bir dispatcher (Dispatchers.IO) kullanılır. // Bu yaklaşım, ana thread’in bloklanmasını engeller ve // uygulamanın kullanıcı arayüzünün sorunsuz çalışmasını sağlar. withContext(Dispatchers.IO) { // Gerçek disk okuma işlemi burada yapılır; // ilgili kaydın dosya sisteminden çekilmesi sağlanır. discReader.read("save/$name") } }
Dispatchers.IO kullanımında dikkat edilmesi gereken önemli bir nokta vardır: Dispatchers.IO varsayılan olarak64 thread (iş parçacığı) ile sınırlıdır; bu sayı backend (arka uç) veya Android tarafında her zaman yeterli olmayabilir.
Eğer her bir isteğin bir blocking call (engelleyici çağrı) yapması gerekiyorsa ve saniyede binlerce istek alıyorsanız,
bu 64 thread için olan kuyruk hızla büyümeye başlayabilir. Böyle bir durumda,
Dispatchers.IO üzerindelimitedParallelism kullanarak, 64’ten fazla iş parçacığına sahip bağımsız bir dispatcher oluşturmayıdüşünebilirsiniz6Ayrıntılar için bkz. “İş Parçacığı Yöneticileri (Dispatchers)” bölümü, “Sabit İş Parçacığı Havuzuna Sahip Dağıtıcı (Dispatcher)” alt başlığı..
// Google hesabı doğrulama işlemlerini yürüten, uygulama içi bir kimlik doğrulama sağlayıcısıdır. // Google Account Verification için modern, ölçeklenebilir ve güvenli bir yapı sunar. class LibraryGoogleAccountVerifier : GoogleAccountVerifier { // Paralel token doğrulama işlemlerinin yönetileceği özel bir coroutine dispatcher tanımlanır. // limitedParallelism(100), aynı anda maksimum 100 paralel iş parçasına izin verir. // Bu, hem yüksek throughput sağlar hem de sistem kaynaklarının aşırı tüketilmesini önler. private val dispatcher = Dispatchers.IO .limitedParallelism(100) // Google'ın kimlik doğrulama (ID Token) altyapısı için doğrulayıcı nesne yapılandırılır. // Verifier, gerekli anahtarlar ve hedef kitle (audience) ile güvenli şekilde başlatılır. private var verifier = GoogleIdTokenVerifier.Builder(..., ...) .setAudience(...) .build() // Verilen Google oturum belirteci (token) ile kullanıcı verilerini asenkron // ve güvenli şekilde elde eden fonksiyon. // Bu fonksiyon, IO-bound ve yüksek eşzamanlılık gerektiren işlemler için // yukarıda tanımlanan dispatcher üzerinde çalışır. override suspend fun getUserData( googleToken: String ): GoogleUserData? = withContext(dispatcher) { // Token doğrulama işlemi başlatılır. verifier.verify(googleToken) // Eğer doğrulama başarılıysa, token içeriğinden (payload) kullanıcı bilgileri çıkarılır. ?.payload // Elde edilen payload, GoogleUserData veri modeline dönüştürülür. ?.let { GoogleUserData( email = it.email, name = it.getString("given_name"), surname = it.getString("family_name"), imageUrl = it.getString("picture"), ) } } }
Dispatchers.IO'dan bağımsız bir limite sahip dispatcher (yürütme bağlamı), bir fonksiyonun çok sayıda coroutinetarafından çağrılabileceğinden ve bu nedenle önemli miktarda thread (iş parçacığı) kullanabileceğinden şüphelenildiği
durumlarda tercih edilmelidir. Böyle durumlarda,
Dispatchers.IO thread’lerini engellemek istemeyiz çünkü hangiişlemlerin bizim sürecimizin tamamlanmasını bekleyeceğini bilemeyiz.
thread havuzlarına sahip dispatcher’lar üzerinde çalışmak gerekir. Peki, bu dispatcher’ların sınırı (limit) ne olmalı?
Buna sizin karar vermeniz gerekir. Eğer bu sayıyı çok küçük tutarsanız, coroutine’ler birbirini bekleyebilir. Eğer çok
büyük yaparsanız, belleği ve işlemci süresini fazla miktarda thread’e harcamış olursunuz.
// Kullanıcıya özel dijital sertifikalar üreten bir servis sınıfıdır. // Gerçekleştirilen işlem, dış bir komut satırı programı çağrılarak yapılır // ve engelleyici (blocking) karakterdedir. // Modern yazılım mimarilerinde dış komut çağrıları, sistem kaynaklarının // verimli yönetimi için özel dispatcher ile izole edilmelidir. class CertificateGenerator { // IO-bound işlemler için, aynı anda maksimum 5 paralel iş parçasın // a izin veren özel bir coroutine dispatcher tanımlanır. // limitedParallelism(5) ile, çoklu sertifika üretim taleplerinde // hem sistem kaynakları korunur hem de yüksek throughput sağlanır. private val dispatcher = Dispatchers.IO .limitedParallelism(5) // Sertifika üretimi, dış komut satırı programı aracılığıyla yapılır; // bu işlem engelleyici niteliktedir ve ana thread’de çalıştırılmamalıdır. // withContext(dispatcher) kullanılarak, engelleyici işlem yalnızca ilgili dispatcher thread’lerinde yürütülür. suspend fun generate(data: CertificateData): UserData = withContext(dispatcher) { // Komut satırı işlemi başlatılır; ilgili sertifika verileri argüman olarak eklenir. // Runtime.exec, yeni bir process başlatır; uzun sürebilir ve kaynak yoğun bir işlemdir. Runtime.getRuntime() .exec("generateCertificate " + data.toArgs()) } }
Dispatchers.Default üzerinde, ana görünümü (main view)değiştiren işlemlerin ise
Dispatchers.Main.immediate üzerinde çalıştırıldığından emin olmalıyız. Bu amaçlawithContext fonksiyonu oldukça kullanışlıdır.// Makine öğrenmesi veya derin öğrenme modelinin eğitimi için kullanılan askıya alınabilir (suspend) fonksiyon. // Yoğun CPU kullanımı gerektiren işlemler, ana thread dışında ve uygun dispatcher ile yürütülmelidir. // Bu yaklaşım, uygulamanın performansını ve yanıt verebilirliğini artırır. suspend fun calculateModel() = // withContext(Dispatchers.Default), yüksek CPU gerektiren işlemlerin // varsayılan (Default) dispatcher üzerinde yürütülmesini sağlar. // Default dispatcher, sistemdeki işlemci çekirdeklerine uygun olarak optimize edilmiş thread havuzu sunar. withContext(Dispatchers.Default) { // model.fit fonksiyonu, veri kümesi üzerinde model eğitimi gerçekleştirir. // Eğitim sırasında epoch, batchSize ve verbose gibi hiperparametreler kullanılır. // Bu işlem uzun sürebilir ve CPU'yu yoğun şekilde kullanabilir. model.fit( dataset = newTrain, epochs = 10, batchSize = 100, verbose = false ) }
// Kullanıcı adı bilgisini arayüzde (UI) güncelleyen askıya alınabilir (suspend) fonksiyon. // UI güncellemelerinin yalnızca ana iş parçacığında (Main thread) yapılması gerekir; // aksi halde uygulama çökebilir veya beklenmedik davranışlar oluşabilir. suspend fun setUserName(name: String) = // withContext(Dispatchers.Main.immediate) kullanılarak, coroutine'in bulunduğu // yerde zaten ana iş parçacığındaysa ek bir gönderim olmadan hemen çalıştırılır. // Eğer farklı bir thread'deyse, iş otomatik olarak ana iş parçacığına alınır. // .immediate uzantısı, UI güncellemelerinde düşük gecikme ve flicker-free (titremesiz) güncelleme sağlar. withContext(Dispatchers.Main.immediate) { // userNameView, UI bileşenidir; text özelliği güncellenerek kullanıcı adı arayüzde gösterilir. // Android veya benzeri frameworklerde, doğrudan UI thread'inde erişim zorunludur. userNameView.text = name }
için idealdir; ancak birden fazla değer beklediğimiz durumlarda bunun yerine
Flow kullanmalıyız. Bu duruma daha öncebir örnek görmüştük: Room kütüphanesinde, tekil veritabanı işlemleri için
suspend fonksiyonları, tablodeğişikliklerini gözlemlemek için ise
Flow tipi kullanılmaktadır.// Room kütüphanesi ile tanımlanmış, veritabanı işlemlerini yöneten DAO (Data Access Object) arayüzüdür. // Bu arayüz, uygulamanın kalıcı veri katmanında konum (location) nesnelerinin güvenli // ve verimli şekilde yönetilmesini sağlar. // DAO, veri erişimini soyutlayarak iş mantığı ve veri katmanı ayrışmasını teşvik eder; // test edilebilirlik ve sürdürülebilirlik sağlar. @Dao interface LocationDao { // Yeni bir konum nesnesini veritabanına ekler. // @Insert ile, Room tarafından ilgili SQL komutu otomatik olarak üretilir. // onConflict = OnConflictStrategy.IGNORE parametresi, // aynı birincil anahtara sahip kayıt varsa eklemeyi yok sayar; veri tutarlılığı sağlanır. // Askıya alınabilir (suspend) fonksiyon; coroutine ile bloklamadan çalışır. @Insert(onConflict = OnConflictStrategy.IGNORE) suspend fun insertLocation(location: Location) // Veritabanındaki tüm konum kayıtlarını siler. // @Query ile doğrudan SQL komutu yazılır; Room bu sorguyu tip güvenli şekilde işler. // Askıya alınabilir fonksiyon; uzun sürebilecek veri tabanı işlemleri ana thread’i bloke etmeden yürütülür. @Query("DELETE FROM location_table") suspend fun deleteLocations() // Veritabanındaki tüm konum kayıtlarını, zamana göre sıralı olarak sürekli gözlemler. // Dönüş türü Flow<List<Location>> olduğu için, // veri tabanında değişiklik oldukça anlık bildirim alınır; // modern reaktif UI ve veri işleme senaryoları için idealdir. @Query("SELECT * FROM location_table ORDER BY time") fun observeLocations(): Flow<List<Location>> }
uygun yöntem
suspend function (askıya alınabilir fonksiyon) kullanmaktır; ancak bir WebSocket kurup gelen mesajlarıdinliyorsak, bunun yerine
Flow kullanmalıyız. Eğer kullandığımız kütüphane Flow döndürmeyi desteklemiyorsa, bu türbir akışı oluşturmak için
callbackFlow (veya channelFlow) kullanılmalıdır. Akış oluşturucuyu (builder) awaitCloseile sonlandırmayı unutmayın7Ayrıntılar için bkz. “Flow Oluşturma (Flow Building)” bölümü, “callbackFlow” alt başlığı..
// Bu fonksiyon, sunucudan gerçek zamanlı (real-time) mesaj almak için // kullanılan bir callback-to-Flow adaptörüdür. // callbackFlow, geleneksel event/callback tabanlı asenkron API’leri, reaktif ve coroutine tabanlı Flow API’sine dönüştürmek için kullanılır. // Bu, modern yazılım geliştirmede, özellikle socket tabanlı gerçek z // amanlı veri iletiminde, kodun daha okunabilir, kontrol edilebilir ve test edilebilir olmasını sağlar. // Gerçek zamanlı mesajlaşma gibi durumlarda, veri akışı abonelik yönetimi // ve kaynak yönetimi ile sıkı şekilde entegre olmalıdır. // Özellikle, arayüzde veya iş mantığında veri akışına abone olan her yeni "collector" için // ayrı kaynak tahsisi ve serbest bırakılması gerekir; // aksi halde memory leak veya resource starvation gibi riskler oluşabilir. fun listenMessages(): Flow<List<Message>> = callbackFlow { // Burada, socket üzerinden "NewMessage" isimli bir olaya abone olunmaktadır. // Her yeni mesaj geldiğinde tetiklenen bu callback, // dış sistemden (ör. Node.js, .NET, vb.) veri alımını mümkün kılar. // Alınan veriler (args), uygun bir dönüşüm fonksiyonu (toMessage) // ile uygulama içi Message nesnesine çevrilir. // Gelen veri, reaktif akışa "trySendBlocking" ile gönderilir; // blocking olması, thread safety ve event kaybı olmadan güvenli veri aktarımı sağlar. // Bu aşamada dikkat edilmesi gereken en önemli konulardan biri, // event’lerin kaybolmaması ve arabellek taşmalarında doğru hata yönetiminin sağlanmasıdır. // Özellikle yoğun trafik ve düşük tüketim (slow consumer) // durumlarında, buffer management stratejileri büyük önem taşır. socket.on("NewMessage") { args -> trySendBlocking(args.toMessage()) } // awaitClose, callbackFlow'un temel kaynak yönetimi noktasıdır. // Akışa abone olan son collector da bağlantısını kopardığında // (örneğin ekran kapandığında veya viewModel yok edildiğinde) burası çağrılır. // Bu noktada, socket üzerindeki event subscription’ların temizlenmesi, // bağlantının sonlandırılması veya başka kaynakların serbest bırakılması gereklidir. // Doğru kaynak yönetimi yapılmazsa, uygulama içinde memory leak, // gereksiz network trafiği veya context leak gibi performans ve güvenlik sorunları ortaya çıkabilir. awaitClose() }
Flow için yaygın bir kullanım alanı da, buton tıklamaları veya metin değişiklikleri gibi UI (kullanıcı arayüzü)olaylarını gözlemlemektir.
// Bu uzantı fonksiyon, Android'in EditText bileşeninde kullanıcı metin girişi // değişikliklerini reaktif ve coroutine tabanlı bir akış (Flow) olarak sunar. // callbackFlow kullanılarak, klasik event/listener tabanlı API’ler modern coroutine // tabanlı, soğuk (cold), abonelik tabanlı veri akışlarına dönüştürülür. // Bu yaklaşım, UI katmanında veri değişikliklerinin kolayca gözlemlenmesi, // arayüzdeki state yönetimiyle kolayca entegre edilmesi ve test edilebilirliği artırmak için kullanılır. // Özellikle MVVM ve benzeri modern mimarilerde, veri kaynağındaki değişiklikleri // ViewModel veya başka katmanlarda izlemek için pratik ve sürdürülebilir bir yöntemdir. fun EditText.listenTextChange(): Flow<String> = callbackFlow { // Kullanıcı her metin değiştirdiğinde tetiklenecek TextWatcher tanımlanır. // Burada doAfterTextChanged, EditText bileşeninin metni değiştikten hemen sonra çağrılan, // modern ve kolay kullanılabilen bir yardımcı fonksiyondur. // Yeni metin, Flow'un buffer'ına blocking şekilde gönderilir; // bu, akış tüketilmediğinde olası event kaybını önler, thread-safe bir aktarım sağlar. // Burada dikkat edilmesi gereken önemli nokta, yoğun metin değişikliklerinde // buffer yönetiminin doğru yapılmasıdır; aksi takdirde UI gecikmeleri veya memory leak oluşabilir. val watcher = doAfterTextChanged { trySendBlocking(it.toString()) } // Akışın ömrü sona erdiğinde (örneğin, abone kalmadığında veya ekran yok edildiğinde), // TextWatcher dinleyicisi EditText'ten kaldırılır. // awaitClose, kaynak yönetimi açısından kritik rol oynar; dinleyicinin kaldırılmaması // durumunda memory leak ve gereksiz callback tetiklenmeleri oluşabilir. // Doğru kaynak temizliği, Android uygulamalarında performans ve güvenilirlik için gereklidir. awaitClose { removeTextChangedListener(watcher) } }
Flow, başka callback functions (geri çağırma fonksiyonları) için de kullanılabilir ve bu callback’ler birden fazladeğer üretebilecekse kesinlikle
Flow tercih edilmelidir.// Bu fonksiyon, callback tabanlı (geleneksel) bir API’yi modern coroutine tabanlı // reaktif akış (Flow) biçiminde kullanılabilir hâle getirir. // callbackFlow, klasik event/callback altyapısını, Flow mimarisi ile entegre ederek, // event-driven programlamanın zorluklarını (ör. callback hell, memory leak) giderir. // Bu desen, modern reaktif yazılım geliştirme paradigmasının temel taşlarından biridir; // lifecycle, iptal ve hata yönetimini otomatik ve güvenli hâle getirir. // Özellikle uzun ömürlü, stateful ya da yüksek frekanslı event akışlarında // kaynak yönetiminin ve thread güvenliğinin sağlanması kritik önemdedir. fun flowFrom(api: CallbackBasedApi): Flow<T> = callbackFlow { // Callback arayüzünü uygulayan anonim bir nesne tanımlanır. // Bu nesne, callback tabanlı API'den gelen olayları (event) yönetmek için gerekli metotları içerir. // Buradaki amaç, API’den gelen değerlerin ve olayların, // coroutine tabanlı flow'un lifecycle'ı ile uyumlu biçimde yönetilmesini sağlamaktır. val callback = object : Callback { // API yeni bir veri yayımladığında, bu metot çağrılır. // Alınan değer trySendBlocking ile flow kanalına eklenir; // thread-safe ve event kaybını önleyici bir yöntemdir. // Yoğun veri trafiğinde, buffer taşması ve backpressure stratejilerinin önemi artar. override fun onNextValue(value: T) { trySendBlocking(value) } // API bir hata yayımladığında, callbackFlow’un bulunduğu coroutine iptal edilir. // cancel fonksiyonu, CancellationException ile birlikte event’in // nedenini ve zincirini (cause) korur. // Bu, coroutine context’inde tüm downstream (aşağı yönlü) collector’ların da // doğru şekilde iptal edilmesini sağlar. // Exception propagation ile üst katmanlarda hata yönetimi, // try/catch veya flow.catch operatörü ile yapılabilir. override fun onApiError(cause: Throwable) { cancel(CancellationException("API Error", cause)) } // API tarafından akış tamamlandığında, flow’un kanalı kapatılır. // Kanalın kapatılması, flow’un lifecycle’ı açısından önemlidir; // collector’lar sonlanır ve cleanup işlemleri başlatılır. override fun onCompleted() = channel.close() } // Callback nesnesi, ilgili API’ye kaydedilir; // böylece API'den gelen tüm event’ler bu nesne üzerinden alınır. // Bu aşama, callbackFlow’un "cold" yani yalnızca abone varsa veri üreteceği garantisini sağlar. api.register(callback) // Akışın ömrü sona erdiğinde veya collector iptal edildiğinde, callback API’den kaldırılır. // awaitClose, kaynak yönetiminin temel noktasıdır; doğru cleanup yapılmazsa, // memory leak ve gereksiz callback çağrıları oluşabilir. // Bu desen, modern coroutine tabanlı reactive programlamada **kaynakların deterministik // ve güvenli serbest bırakılması** için zorunludur. awaitClose { api.unregister(callback) } }
flow oluşturucuda (builder) belirli bir dispatcher (işlem bağlamı) kullanmanız gerekiyorsa, oluşturulan akışüzerinde
flowOn fonksiyonunu kullanmalısınız8Ayrıntılar için bkz. “Flow Yaşam Döngüsü Fonksiyonları (Flow lifecycle functions)” bölümü, “flowOn” alt başlığı..// Bu fonksiyon, sonsuz Fibonacci dizisini coroutine tabanlı reaktif veri akışı (Flow) olarak üretir. // Başlangıçta 0 ve 1 değerlerini yayınlar; // ardından klasik algoritmayla sonsuz döngüde yeni Fibonacci sayıları hesaplanır. // Hesaplamada BigDecimal kullanılır; böylece çok büyük sayılar güvenli ve hassas şekilde işlenebilir, // integer overflow riski ortadan kalkar. // Hesaplama işlemleri, flowOn(Dispatchers.Default) ile ana thread’den ayrılır; // çok çekirdekli ortamlarda yüksek performans ve thread safety sağlanır. // Bu desen, yüksek hesaplama gerektiren reaktif veri üretimi için modern coroutine mimarisinde standarttır. fun fibonacciFlow(): Flow<BigDecimal> = flow { var a = BigDecimal.ZERO var b = BigDecimal.ONE emit(a) emit(b) while (true) { val temp = a a = b b += temp emit(b) } }.flowOn(Dispatchers.Default) // Belirtilen bir dizindeki tüm dosyaların içeriğini, sıralı // ve reaktif olarak yayınlayan veri akışı (Flow) fonksiyonudur. // channelFlow, dış dünyadan (dosya sistemi, ağ, sensör vb.) // gelen olayları thread-safe şekilde akışa dönüştürmek için idealdir. // File(path).takeIf { it.exists() } ile, dizinin varlığı güvenli biçimde doğrulanır; // null-safety garanti altına alınır. // Dizin mevcutsa, içindeki tüm dosyalar listelenir ve her birinin içeriği send ile akışa gönderilir. // Dosya içerikleri non-blocking şekilde ve memory-friendly olarak aktarılır; // büyük koleksiyonlarda uygulamanın stabilitesi korunur. // flowOn(Dispatchers.IO), dosya okuma işlemlerinin IO-bound özel thread havuzunda yürütülmesini sağlar; // ana thread asla bloklanmaz. fun filesContentFlow(path: String): Flow<String> = channelFlow { File(path).takeIf { it.exists() } ?.listFiles() ?.forEach { send(it.readText()) } }.flowOn(Dispatchers.IO)
- 1.Ayrıntılar için bkz. “Askıya Alma (Suspension) Mekanizması Nasıl Çalışır?” bölümü, “Bir Değer ile Devam Etme” alt başlığı. ↩
- 2.Ayrıntılar için bkz. “İptal Mekanizması (Cancellation)” bölümü, “invokeOnCompletion” alt başlığı. ↩
- 3.Ayrıntılar için bkz. “Askıya Alma (Suspension) Mekanizması Nasıl Çalışır?” bölümü, “İstisna (Exception) ile Devam Ettirme (Resume)” alt başlığı. ↩
- 4.Ayrıntılar için bkz. “İş Parçacığı Yöneticileri (Dispatchers)” bölümü. ↩
- 5.Ayrıntılar için bkz. “İş Parçacığı Yöneticileri (Dispatchers)” bölümü, “Giriş/Çıkış (GÇ/IO) Dağıtıcısı” alt başlığı. ↩
- 6.Ayrıntılar için bkz. “İş Parçacığı Yöneticileri (Dispatchers)” bölümü, “Sabit İş Parçacığı Havuzuna Sahip Dağıtıcı (Dispatcher)” alt başlığı. ↩
- 7.Ayrıntılar için bkz. “Flow Oluşturma (Flow Building)” bölümü, “callbackFlow” alt başlığı. ↩
- 8.Ayrıntılar için bkz. “Flow Yaşam Döngüsü Fonksiyonları (Flow lifecycle functions)” bölümü, “flowOn” alt başlığı. ↩