Coroutine Scope Nasıl Oluşturulur?

Coroutine Scope Nasıl Oluşturulur?

Bu metin, Kotlin Coroutines kitabının bir bölümüdür. Kitabın tamamına LeanPub üzerinden erişebilirsiniz
Önceki bölümlerde, doğru bir scope (kapsam) oluşturmak için gereken tüm bileşenleri ele aldık. Şimdi ise bu bilgileri
özetleme ve tipik kullanım biçimlerini inceleme zamanı geldi.

CoroutineScope fabrika fonksiyonu

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 }
Bu nedenle, bir sınıf bu arayüzü (interface) uygulayarak doğrudan coroutine oluşturucularını (coroutine builders) çağırabilir.
/** * 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() } }
Ancak bu yaklaşım pek yaygın değildir çünkü pratik olmasına rağmen, böyle bir sınıf içinde doğrudan cancel veya
ensureActive gibi diğer CoroutineScope metodlarının çağrılabilmesi sorun yaratabilir. Hatta kazara bile olsa, birisi
tü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 } }
Bir coroutine scope nesnesi oluşturmanın en kolay yolu CoroutineScope fabrika fonksiyonunu (factory function)
kullanmaktır1. Bu fonksiyon, verilen bağlam (context) ile bir scope oluşturur (ve eğer bağlamda önceden bir Job
yoksa, 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)" }

Arka plan kapsamı (background scope) oluşturma

Eğer bir eşzamanlı olmayan (asenkron) coroutine başlatmanız gerekiyorsa, bir scope'a (kapsama) ihtiyacınız vardır. Bir
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.
Bu tür bir scope genellikle kurucu metod (constructor) aracılığıyla sınıfa enjekte edilir ve genellikle scope ya da
backgroundScope 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... }
Peki, böyle bir scope nasıl oluşturulmalıdır? Genellikle aşağıdaki özelliklere sahip olması istenir:
  • Belirli bir dispatcher (yürütücü) kullanmalıdır;
  • SupervisorJob iç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 bir CoroutineExceptionHandler içerebilir2.
Dispatcher seçimi konusunda en yaygın seçenekler şunlardır:
  • 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ızca limitedParallelism ö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.Default kadar CPU verimlidir, ancak yanlışlıkla yapılan engellemelerde daha güvenlidir;
  • Executors kullanı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.
Aşağıda Spring Boot uygulaması için örnek bir yapılandırma yer almaktadır. Bu örnekte SupervisorJob, sınırlı sayıda
thread'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 ) }
Benzer bir scope, arka uç (backend) uygulamalarında her bir istek (request) için coroutine başlatmak amacıyla da
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.
Elbette, bir scope ihtiyaç duyan sınıf içinde de oluşturulabilir. Bağımlılık enjeksiyonu (dependency injection) zorunlu
değildir, ancak test süreçlerinde ve kodun daha modüler hale getirilmesinde oldukça faydalıdır.
Aşağıda bir sınıf içerisinde scope oluşturmanın örneği verilmiştir:
/** * 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) } } } }

Android'de scope oluşturma

Android platformunda bir scope oluştururken genellikle aşağıdaki hedefler doğrultusunda yapılandırma yapılır:
  • Varsayılan dispatcher olarak Dispatchers.Main.immediate kullanılır;
  • Bir coroutine başarısız olduğunda diğerlerinin iptal edilmesini önlemek için SupervisorJob kullanı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 CoroutineExceptionHandler tanımlanır.
Aşağıda, bir temel (base) view model içinde scope oluşturmanın nasıl görünebileceğine dair bir örnek verilmiştir:
/** * 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() } }
Modern Android uygulamalarında, kendi scope'unuzu tanımlamak yerine hazır scope'ları da kullanabilirsiniz:
  • viewModelScope – kullanmak için androidx.lifecycle kütüphanesinin lifecycle-viewmodel-ktx paketinin 2.2.0 veya
    üzeri bir sürümü gereklidir;
  • lifecycleScope – kullanmak için androidx.lifecycle kütüphanesinin lifecycle-runtime-ktx paketinin 2.2.0 veya
    üzeri bir sürümü gereklidir.
Bu scope'ların çalışma prensipleri, az önce yapılandırdığımız özel scope ile neredeyse aynıdır:
Dispatchers.Main.immediate ve SupervisorJob kullanırlar ve ilgili ViewModel ya da LifecycleOwner yok
edildiğ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() } }
Eğer scope içinde özel bir bağlam (context) kullanmamız gerekmiyorsa (örneğin CoroutineExceptionHandler gibi),
viewModelScope ve lifecycleScope kullanmak hem pratik hem de önerilen bir yaklaşımdır.
Bu nedenle, çoğu Android uygulaması bu yöntemi tercih etmektedir.
/** * 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 } } }

Özet

Bu bölümde, farklı ortamlarda coroutine scope (iş kapsamı) oluşturmanın nasıl gerçekleştirileceği ele alınmıştır. Bu tür
bir scope, coroutine başlatmak ve bunların yaşam döngülerini yönetmek için kullanılır.
En yaygın scope oluşturma yöntemi olarak 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ız
gerektiğini öğrendik. Özel bir dispatcher ve özel bir exception handler tanımlayarak hata yönetimini özelleştirebiliriz.
Ayrıca, context üzerinden cancelChildren çağrısı yaparak tüm coroutine'leri iptal edebileceğimizi gördük. Son
olarak, Android uygulamalarında viewModelScope ve lifecycleScope kullanabileceğimizi öğrendik.
  1. 1.Yapılandırıcıya (constructor) benzeyen fonksiyonlara sahte yapılandırıcı (fake constructor) denir. Bu desen, ↩
  2. 2.Bu, bir yazılım veriyolu (software bus) kullandığımız durumlarda (örneğin Apache Kafka) kullanılan popüler bir ↩