
Bu metin, Kotlin Coroutines kitabının bir bölümüdür. Kitabın tamamına LeanPub üzerinden erişebilirsiniz
özetleme ve tipik kullanım biçimlerini inceleme zamanı geldi.
CoroutineScope, tek bir özelliğe (property) sahip bir arabirimdir (interface): coroutineContext./** * CoroutineScope interface'i, coroutine'lerin oluşturulabileceği bir kapsamı temsil eder. * * Bu interface, structured concurrency prensiplerini uygulamak için temel yapı taşıdır. * Her coroutine bir kapsama (scope) bağlıdır ve bu kapsamın yaşam döngüsünü takip eder. */ interface CoroutineScope { /** * Bu scope'a ait olan CoroutineContext. * * CoroutineContext, coroutine'in çalışma ortamını belirleyen elemanların bir koleksiyonudur: * - Job/SupervisorJob: Coroutine'in yaşam döngüsünü ve iptal davranışını kontrol eder * - CoroutineDispatcher: Coroutine'in hangi thread veya thread havuzunda çalışacağını belirler * - CoroutineExceptionHandler: Yakalanmamış istisnalar için davranışı tanımlar * - CoroutineName: Debugging için coroutine'e isim verir * * Bir scope üzerinde launch veya async çağrıldığında, oluşturulan her coroutine * bu context'i miras alır ve o scope'a bağlı olur. */ val coroutineContext: CoroutineContext }
/** * CoroutineScope interface'ini implemente eden bir sınıf örneği. * Bu sınıf, kendi içinde bir coroutine scope olarak davranır ve * doğrudan coroutine builder'ları (launch, async) çağırabilir. */ class SomeClass : CoroutineScope { /** * CoroutineScope interface'inden override edilen coroutineContext. * * Bu örnekte sadece bir Job() tanımlanmış. Bu, sınıfın kendi coroutine kapsamını * oluşturur ve bu sınıfta başlatılan tüm coroutine'ler bu job'a child olarak bağlanır. * * Not: Gerçek uygulamalarda genellikle bu context'e bir dispatcher ve hata yakalayıcı * da eklenir, örneğin: Job() + Dispatchers.Main + exceptionHandler */ override val coroutineContext: CoroutineContext = Job() /** * Bu metot çağrıldığında, sınıfın scope'u üzerinde yeni bir coroutine başlatır. * * SomeClass bir CoroutineScope olduğu için, doğrudan launch çağrılabilir * ve bu, this.launch() ile aynı anlama gelir. */ fun onStart() { launch { // Burada asenkron çalışacak kod bloğu yer alır // Bu coroutine, SomeClass'ın job'ına bağlı olarak çalışır } } /** * Bu sınıf için bir temizleme metodu. * Sınıfın yaşam döngüsü sona erdiğinde çağrılmalıdır. * * Sınıfın job'ını iptal ederek tüm aktif coroutine'leri sonlandırır. */ fun cleanup() { coroutineContext[Job]?.cancel() } }
cancel veyaensureActive gibi diğer CoroutineScope metodlarının çağrılabilmesi sorun yaratabilir. Hatta kazara bile olsa, birisitüm scope'u iptal edebilir (cancel), bu da artık coroutine'lerin başlatılamayacağı anlamına gelir. Bu nedenle,
genellikle bir coroutine scope'u bir özellik (property) olarak nesne şeklinde tutmayı ve coroutine oluşturucuları bu
nesne üzerinden çağırmayı tercih ederiz.
/** * CoroutineScope'u property olarak tutan daha güvenli yaklaşım. * Bu yaklaşım, interface implementasyonuna göre daha yaygın ve önerilen bir patterndir. */ class SomeClass { /** * Sınıfın kendi coroutine scope'u bir property olarak tanımlanır. * * Bu yaklaşımda: * 1. Scope doğrudan sınıfın bir parçası değil, bir komponenti olarak tutulur * 2. Scope'a erişim daha kontrollüdür * 3. Job/context yönetimi daha açık ve güvenlidir * * İdeal olarak, gerçek uygulamalarda context daha kapsamlı tanımlanır: * val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main + exceptionHandler) */ val scope: CoroutineScope = CoroutineScope(Job()) /** * Coroutine'ler scope property'si üzerinden başlatılır. * Bu, daha belirgin ve kolay takip edilebilen bir yapı sağlar. */ fun onStart() { scope.launch { // Asenkron operasyonlar burada gerçekleştirilir // Bu coroutine scope.coroutineContext'e bağlı olarak çalışır } } /** * Sınıfın temizlenmesi sırasında scope'u güvenli şekilde iptal etmek için * açık bir metot tanımlanır. */ fun cleanup() { scope.cancel() // Tüm coroutine'leri iptal eder } }
CoroutineScope fabrika fonksiyonunu (factory function)kullanmaktır1Yapılandırıcıya (constructor) benzeyen fonksiyonlara sahte yapılandırıcı (fake constructor) denir. Bu desen,. Bu fonksiyon, verilen bağlam (context) ile bir scope oluşturur (ve eğer bağlamda önceden bir
Jobyoksa, yapılandırılmış eşzamanlılık (structured concurrency) için ek bir
Job nesnesi de sağlar)./** * CoroutineScope fabrika fonksiyonu - Kotlin Coroutines API'ının temel yapı taşlarından biri. * * Bu fonksiyon, verilen CoroutineContext ile bir CoroutineScope nesnesi oluşturur. * * @param context Oluşturulacak scope için temel CoroutineContext * @return Belirtilen context'i kullanan yeni bir CoroutineScope nesnesi */ public fun CoroutineScope( context: CoroutineContext ): CoroutineScope = ContextScope( // Eğer verilen context içinde zaten bir Job varsa, context'i olduğu gibi kullan // Yoksa, context'e yeni bir Job ekle if (context[Job] != null) context else context + Job() ) /** * CoroutineScope interface'ini implemente eden dahili bir sınıf. * * Bu sınıf, CoroutineScope fabrika fonksiyonu tarafından oluşturulan * scope nesnelerinin gerçek implementasyonudur. * * @param context Scope'un kullanacağı CoroutineContext */ internal class ContextScope( context: CoroutineContext ) : CoroutineScope { /** * CoroutineScope interface'inden override edilen coroutineContext. * Fabrika fonksiyonu tarafından sağlanan context'i tutar. */ override val coroutineContext: CoroutineContext = context /** * Bu scope'un string temsilini döndürür. * Debugging ve loglama amacıyla kullanışlıdır. */ override fun toString(): String = "CoroutineScope(coroutineContext=$coroutineContext)" }
askıya alınabilir fonksiyondan (suspending function) gelen scope'u kullanmak, bu coroutine'i çağıran coroutine'e bağlar.
Ancak yeni bir işlem başlatmak istiyorsanız, özel bir scope tanımlamanız gerekir.
scope ya dabackgroundScope olarak adlandırılır./** * CacheRefreshService sınıfı - Dış servislerden veri yenilemesi için kullanılır * * Bu sınıf, constructor'dan bir CoroutineScope enjekte ederek * yapılandırılmış eşzamanlılık (structured concurrency) prensiplerini uygular. * * @param userService Kullanıcı verilerini yenileyen servis * @param newsService Haber verilerini yenileyen servis * @param backgroundScope Asenkron işlemlerin çalıştırılacağı coroutine scope */ class CacheRefreshService( private val userService: UserService, private val newsService: NewsService, private val backgroundScope: CoroutineScope, ) { /** * Hem kullanıcı hem de haber verilerini yeniler. * * Bu metot, dışarıdan enjekte edilen scope üzerinde * yeni bir coroutine başlatır ve her iki servisin yenileme işlemlerini * sıralı olarak çalıştırır. */ fun refresh() { scope.launch { userService.refresh() newsService.refresh() } } } /** * DataSyncManager sınıfı - Sunucu ile periyodik veri senkronizasyonu yapar * * Bu sınıf başlatıldığında, arka planda sürekli çalışan * bir senkronizasyon işlemi başlatır. * * @param backgroundScope Asenkron işlemlerin çalıştırılacağı coroutine scope */ class DataSyncManager( backgroundScope: CoroutineScope, ) { /** * Sınıf oluşturulduğunda, arka plan scope'unda sürekli çalışan * bir senkronizasyon döngüsü başlatılır. * * Bu döngü: * 1. Sunucu ile veri senkronizasyonu yapar * 2. Belirli bir süre bekler * 3. Hata durumunda yeniden deneme mantığı uygular * 4. Coroutine iptal edilene kadar devam eder */ init { backgroundScope.launch { while (isActive) { // CoroutineScope'un isActive özelliği - iptal kontrolü retryOnFailure { // Özel bir extension fonksiyon olmalı - hata durumunda yeniden deneme syncDataWithServer() // Sunucu ile senkronizasyon işlemi delay(syncIntervalMillis) // Sonraki senkronizasyon öncesi bekleme } } } } // Sınıfın diğer metot ve özellikleri... }
- Belirli bir dispatcher (yürütücü) kullanmalıdır;
SupervisorJobiçermelidir; böylece bu scope içinde başlatılan coroutine'lerden biri başarısız olsa bile diğerleri
iptal edilmez;- İsteğe bağlı olarak, özel bir günlükleme (logging) işlemi yapmak, uygun hata kodlarıyla yanıt vermek ya da ölü
mesajlar (dead letters) göndermek için özel birCoroutineExceptionHandleriçerebilir2Bu, bir yazılım veriyolu (software bus) kullandığımız durumlarda (örneğin Apache Kafka) kullanılan popüler bir.
Dispatchers.Default: Eğer hiçbir engelleyici (blocking) çağrı yapılmayacağından eminseniz, bu oldukça iyi bir
tercihtir;Dispatchers.IO: Eğer thread'leri engelleyecekseniz (örneğin dosya işlemleri veya veritabanı bağlantıları gibi), bu
uygundur; yalnızcalimitedParallelismözelliğini servislerde kullanmayı unutmayın;Dispatchers.IO.limitedParallelism(n): Thread engelleme planlıyorsanız ya da bunu planlamasanız bile bir geliştirici
yanlışlıkla thread'i engellerse diye önlem almak istiyorsanız, bu seçeneği kullanabilirsiniz. Bu yapı
Dispatchers.Defaultkadar CPU verimlidir, ancak yanlışlıkla yapılan engellemelerde daha güvenlidir;Executorskullanılarak oluşturulmuş özel bir dispatcher: Eğer Kotlin Coroutine dispatcher'larıyla yapılamayan (
öncelik, ad, tür gibi) özel thread yapılandırmaları yapmak istiyorsanız bu yöntem tercih edilir.
SupervisorJob, sınırlı sayıdathread'e sahip özel bir dispatcher ve tüm yakalanmamış hataları günlüğe kaydeden özel bir exception handler
kullanılmıştır.
/** * Spring Boot için Coroutine scope yapılandırma sınıfı. * * Bu Spring Configuration sınıfı, uygulama genelinde kullanılabilecek * optimize edilmiş ve yapılandırılmış CoroutineScope ve bileşenlerini * Spring Bean olarak tanımlar. */ @Configuration public class CoroutineScopeConfiguration { /** * Sınırlı paralellikle IO Dispatcher Bean'i tanımlar. * * Bu dispatcher, aynı anda en fazla 50 coroutine'in paralel * çalışmasına izin verir. Bu, kaynakların daha verimli kullanılmasını * ve sistemin aşırı yüklenmesini önlemeyi sağlar. * * limitedParallelism, varsayılan Dispatchers.IO thread havuzundan * bir görünüm (view) oluşturur ve bu görünümün aynı anda kullanabileceği * maksimum thread sayısını sınırlar. * * @return Paralelliği sınırlandırılmış bir CoroutineDispatcher */ @Bean fun coroutineDispatcher(): CoroutineDispatcher = Dispatchers.IO.limitedParallelism(50) /** * Yakalanmamış coroutine istisnaları için hata işleyici Bean'i tanımlar. * * Bu handler, coroutine'lerde yakalanmayan tüm istisnaları loglar ve * izleme servisine raporlar. Bu sayede uygulama çökmeden hataları * izleyebilir ve gerekli önlemleri alabilirsiniz. * * @param monitoringService Hataları raporlamak için kullanılan servis * @return Coroutine istisnalarını yakalayan ve işleyen bir handler */ @Bean fun coroutineExceptionHandler( monitoringService: MonitoringService, ): CoroutineExceptionHandler { val logger = LoggerFactory.getLogger("DefaultHandler") return CoroutineExceptionHandler { _, throwable -> logger.error("Unhandled exception", throwable) monitoringService.reportError(throwable) } } /** * Önceden tanımlanan bileşenleri kullanarak uygulama genelindeki * coroutine scope'u tanımlar. * * Bu scope: * 1. SupervisorJob kullanarak bir hatanın tüm sistemi çöktürmesini önler * 2. Özel yapılandırılmış ve sınırlandırılmış dispatcher kullanarak * sistem kaynaklarını optimize eder * 3. Merkezi hata işleme mekanizması sayesinde istisnaları yakalar * * @param coroutineDispatcher Scope'un kullanacağı dispatcher * @param coroutineExceptionHandler Scope'un kullanacağı hata işleyici * @return Uygulama genelinde kullanılacak optimize edilmiş bir CoroutineScope */ @Bean fun coroutineScope( coroutineDispatcher: CoroutineDispatcher, coroutineExceptionHandler: CoroutineExceptionHandler, ) = CoroutineScope( SupervisorJob() + coroutineDispatcher + coroutineExceptionHandler ) }
kullanılabilir. Ancak bu işlem genellikle kullandığımız çatı (framework) tarafından gerçekleştirilir. Hem Spring Boot
hem de Ktor, her istek için coroutine başlatmanın kendi yöntemlerine sahiptir.
değildir, ancak test süreçlerinde ve kodun daha modüler hale getirilmesinde oldukça faydalıdır.
/** * DocumentsUpdater sınıfı - Belgeleri güncellemek için kullanılan sınıf * * @param documentsFetcher Belgeleri getirmek için kullanılan servis */ class DocumentsUpdater( val documentsFetcher: DocumentsFetcher, ) { /** * I/O işlemleri için özel yapılandırılmış dispatcher. * Aynı anda en fazla 50 coroutine'in paralel çalışmasına izin verir. */ private val disp = Dispatchers.IO.limitedParallelism(50) /** * Belge güncelleme işlemleri için kullanılan coroutine scope. * SupervisorJob kullanılarak bir coroutine'deki hataların diğerlerini etkilememesi sağlanır. */ private val scope = CoroutineScope(SupervisorJob() + disp) /** * Belgelerin kaydedileceği dizin */ private val documentsDir = File("documents") /** * Belgeleri günceller. * * Bu metot asenkron olarak: * 1. DocumentsFetcher servisinden belgeleri getirir * 2. Her belge için dosya oluşturur * 3. Belge içeriğini dosyaya yazar * * İşlemler arka planda coroutine ile gerçekleştirilir, * bu sayede ana thread bloklanmaz. */ fun updateBooks() { scope.launch { val documents = documentsFetcher.fetch() documents.forEach { document -> val file = File(documentsDir, document.name) file.writeBytes(document.content) } } } }
- Varsayılan dispatcher olarak
Dispatchers.Main.immediatekullanılır; - Bir coroutine başarısız olduğunda diğerlerinin iptal edilmesini önlemek için
SupervisorJobkullanılır; - Görünüm (view) veya view model yok edildiğinde tüm coroutine'lerin iptal edilmesi sağlanır;
- Varsayılan hata işleme yöntemlerini belirlemek amacıyla büyük olasılıkla bir
CoroutineExceptionHandlertanımlanır.
/** * Tüm ViewModel'ler için temel sınıf. * * Bu sınıf, ViewModel'lerde coroutine kullanımı için ortak altyapı sağlar * ve hata yönetimini merkezileştirir. */ abstract class BaseViewModel : ViewModel() { /** * Oluşan hataları yaymak için kullanılan dahili flow. * MutableSharedFlow tipinde olduğundan içine değer yazılabilir. */ private val _failure = MutableSharedFlow<Throwable>() /** * Dışarıya sadece okunabilir bir flow olarak sunulan hata akışı. * Bu flow'a alt sınıflar veya dış kodlar tarafından yazılamaz, sadece gözlemlenebilir. */ val failure: SharedFlow<Throwable> = _failure /** * Coroutine'ler için özel yapılandırılmış bağlam (context). * * - Dispatchers.Main.immediate: UI thread'inde hemen çalışmayı sağlar * - SupervisorJob: Bir coroutine'deki hatanın diğerlerini etkilememesini sağlar * - CoroutineExceptionHandler: Yakalanmayan hataları _failure flow'una yönlendirir */ private val context = Dispatchers.Main.immediate + SupervisorJob() + CoroutineExceptionHandler { _, throwable -> _failure.tryEmit(throwable) } /** * Alt sınıfların coroutine'ler başlatmak için kullanacağı scope. * Özel yapılandırılmış context ile oluşturulmuştur. */ protected val scope = CoroutineScope(context) /** * ViewModel imha edildiğinde çağrılır. * Tüm child coroutine'leri iptal eder, fakat parent job'ı korur. */ override fun onCleared() { context.cancelChildren() } }
viewModelScope– kullanmak içinandroidx.lifecyclekütüphanesininlifecycle-viewmodel-ktxpaketinin2.2.0veya
üzeri bir sürümü gereklidir;lifecycleScope– kullanmak içinandroidx.lifecyclekütüphanesininlifecycle-runtime-ktxpaketinin2.2.0veya
üzeri bir sürümü gereklidir.
Dispatchers.Main.immediate ve SupervisorJob kullanırlar ve ilgili ViewModel ya da LifecycleOwner yokedildiğinde (destroyed) kapsamlarını iptal ederler (cancel).
// Implementation from lifecycle-viewmodel-ktx version 2.4.0 /** * ViewModel sınıfları için otomatik olarak yönetilen bir CoroutineScope sağlar. * * Bu extension property, herhangi bir ViewModel instance'ı için yaşam döngüsüne * bağlı bir coroutine scope döndürür. ViewModel imha edildiğinde otomatik olarak iptal edilir. * * Bu, AndroidX ViewModel KTX kütüphanesindeki viewModelScope'un gerçek implementasyonudur. */ public val ViewModel.viewModelScope: CoroutineScope get() { // Önce mevcut bir scope olup olmadığını kontrol et val scope: CoroutineScope? = this.getTag(JOB_KEY) if (scope != null) { return scope } // Yoksa yeni bir scope oluştur ve ViewModel'e ekle return setTagIfAbsent( JOB_KEY, CloseableCoroutineScope( // SupervisorJob + Main.immediate dispatcher kullanılarak // UI thread'de hemen çalışan ve bir coroutine'deki hatanın // diğerlerini etkilemediği bir context oluşturulur SupervisorJob() + Dispatchers.Main.immediate ) ) } /** * ViewModel yaşam döngüsüne bağlı, kapatılabilir bir CoroutineScope implementasyonu. * * Bu sınıf hem Closeable hem de CoroutineScope interface'lerini implement eder, * böylece ViewModel imha edildiğinde scope'un düzgün bir şekilde kapatılmasını sağlar. * * @param context Scope için kullanılacak coroutine context'i */ internal class CloseableCoroutineScope( context: CoroutineContext ) : Closeable, CoroutineScope { // Verilen context'i scope'un coroutineContext'i olarak kullan override val coroutineContext: CoroutineContext = context /** * Scope'u kapatır ve tüm aktif coroutine'leri iptal eder. * ViewModel.onCleared() çağrıldığında otomatik olarak tetiklenir. */ override fun close() { coroutineContext.cancel() } }
CoroutineExceptionHandler gibi),viewModelScope ve lifecycleScope kullanmak hem pratik hem de önerilen bir yaklaşımdır./** * Makaleler listesi ekranı için ViewModel. * * Bu sınıf, makalelerin yüklenmesi, görüntülenmesi ve ilgili UI durumlarının * yönetilmesinden sorumludur. * * @param produceArticles Makaleleri getirmek için kullanılan use case */ class ArticlesListViewModel( private val produceArticles: ProduceArticlesUseCase, ) : ViewModel() { /** * İlerleme çubuğunun görünürlük durumunu tutan dahili akış. * Başlangıçta görünmez (false) olarak ayarlanmıştır. */ private val _progressVisible = MutableStateFlow(false) /** * İlerleme çubuğunun görünürlük durumunu dışarıya sunan salt okunur akış. */ val progressBarVisible: StateFlow<Boolean> = _progressVisible /** * Makaleler listesinin mevcut durumunu tutan dahili akış. * Başlangıçta Initial durumunda başlar. */ private val _articlesListState = MutableStateFlow<ArticlesListState>(Initial) /** * Makaleler listesinin durumunu dışarıya sunan salt okunur akış. */ val articlesListState: StateFlow<ArticlesListState> = _articlesListState /** * ViewModel oluşturulduğunda çağrılır ve makaleleri yükler. * * Tüm bu işlemler, viewModelScope içinde gerçekleştirilir ve * ViewModel imha edildiğinde otomatik olarak iptal edilir. */ fun onCreate() { viewModelScope.launch { // 1. İlerleme çubuğunu görünür yapar _progressVisible.value = true // 2. Makaleleri asenkron olarak getirir val articles = produceArticles.produce() // 3. Makaleleri UI state'ine yükler _articlesListState.value = ArticlesLoaded(articles) // 4. İlerleme çubuğunu gizler _progressVisible.value = false } } }
bir scope, coroutine başlatmak ve bunların yaşam döngülerini yönetmek için kullanılır.
CoroutineScope fabrika fonksiyonunun (factory function) kullanıldığınıgördük. Bir coroutine başarısız olduğunda diğerlerinin iptal edilmesini önlemek için
SupervisorJob kullanmamızgerektiğini öğrendik. Özel bir dispatcher ve özel bir exception handler tanımlayarak hata yönetimini özelleştirebiliriz.
context üzerinden cancelChildren çağrısı yaparak tüm coroutine'leri iptal edebileceğimizi gördük. Sonolarak, Android uygulamalarında
viewModelScope ve lifecycleScope kullanabileceğimizi öğrendik.