
Bu metin, Kotlin Coroutines kitabının bir bölümüdür. Kitabın tamamına LeanPub üzerinden erişebilirsiniz
CoroutineContexttüründe olduğu görülmektedir.
// CoroutineScope üzerinde tanımlanmış bir extension fonksiyon public fun CoroutineScope.launch( // Coroutine için kullanılacak bağlam (context) // Varsayılan değer olarak boş bağlam kullanılır // CoroutineContext, Dispatcher, Job, CoroutineName gibi öğeleri içerebilir context: CoroutineContext = EmptyCoroutineContext, // Coroutine'in nasıl başlatılacağını belirler // DEFAULT: Hemen başlatılır // LAZY: Sadece sonuç gerektiğinde başlatılır // ATOMIC: Başlatılana kadar iptal edilemez // UNDISPATCHED: İlk askıya alınmaya kadar mevcut thread'de çalışır start: CoroutineStart = CoroutineStart.DEFAULT, // Coroutine içinde çalıştırılacak suspend fonksiyon bloğu // CoroutineScope'un receiver olduğu bir lambda fonksiyonu // Bu sayede blok içinde aynı scope üzerinde başka coroutine'ler başlatılabilir block: suspend CoroutineScope.() -> Unit // Fonksiyon, başlatılan coroutine'i temsil eden bir Job nesnesi döndürür // Job nesnesi ile coroutine'in yaşam döngüsü kontrol edilebilir // (iptal etme, tamamlanmasını bekleme vs.) ): Job { // Fonksiyon gövdesi burada olmalı (boş gösterilmiş) }
CoroutineScope türündedir1Terminolojiyi netleştirelim. launch fonksiyonu, CoroutineScope üzerinde tanımlanmış bir genişletme (*. Bu CoroutineScope önemli bir kavramgibi görünüyor, öyleyse tanımına bakalım:
// Kotlin Coroutine sisteminde kullanılan temel bir arayüz (interface) public interface CoroutineScope { // Coroutine'lerin çalışacağı bağlamı (context) tanımlayan özellik // Bu context, coroutine'in davranışını belirleyen çeşitli öğeleri içerir public val coroutineContext: CoroutineContext }
CoroutineScope, yalnızca CoroutineContext için bir sarmalayıcıdır (wrapper). Şimdi, Continuationtanımını hatırlayalım.
/** * Kotlin Coroutine sisteminde asenkron işlemlerin * devam noktalarını temsil eden arayüz. * Bu arayüz, coroutine'lerin askıya alınıp (suspend) * daha sonra devam ettirilmesi (resume) * mekanizmasının temelini oluşturur. * * @param T Continuation'ın işleyeceği değerin tipi. "in" anahtar kelimesi * bu tipinkontravaryan (contravariant) olduğunu belirtir, yani * T ve T'nin alt tipleri kabul edilebilir. */ public interface Continuation<in T> { /** * Bu continuation'ın çalışacağı coroutine bağlamı. * Bu bağlam, coroutine'in davranışını belirleyen Dispatcher, Job, * exception handler gibi öğeleri içerir. */ public val context: CoroutineContext /** * Askıya alınmış (suspended) bir coroutine'i devam ettirmek için çağrılan fonksiyon. * Asenkron işlem tamamlandığında veya bir hata oluştuğunda çağrılır. * * @param result İşlemin sonucunu veya oluşan hatayı kapsayan Result nesnesi. * Eğer işlem başarılı olursa, T tipinde bir değer ile sonuçlanır. * Eğer bir hata oluşursa, Result içinde bir exception yer alır. */ public fun resumeWith(result: Result<T>) }
Continuation, aynı zamanda en önemli Kotlin eşzamanlı programlama (coroutine) bileşenleri tarafından kullanılanCoroutineContext içeriğini barındırır. Bu bağlamın bu kadar önemli olması, onun temel bir kavram olduğunu gösteriyor.Peki,
CoroutineContext tam olarak nedir?CoroutineContext, bir öğeyi veya birden fazla öğeyi temsil eden bir arayüzdür. Kavramsal olarak bir map veya setkoleksiyonuna benzer:
Job, CoroutineName, CoroutineDispatcher gibi Element örneklerinden oluşan indekslenmiş birkoleksiyondur.
CoroutineContext.Element aynı zamanda bir CoroutineContext örneğidir ve birden fazla öğenin bir araya gelmesiyleoluşabilir. Bu yapı,
CoroutineContext'in Composite (Bileşik) tasarım desenini uyguladığı anlamına gelir.import kotlinx.coroutines.CoroutineName import kotlinx.coroutines.Job import kotlin.coroutines.CoroutineContext //Örnek Başlangıcı /** * Bu örnek kod, Kotlin Coroutine sisteminde CoroutineContext ve onun * elementlerininnasıl oluşturulduğunu ve birleştirildiğini göstermektedir. */ fun main() { // CoroutineName oluşturma - coroutine'e isim veren bir context elementi val name: CoroutineName = CoroutineName("A name") // CoroutineName aynı zamanda bir CoroutineContext.Element'tir val element: CoroutineContext.Element = name // Ve bir Element aynı zamanda bir CoroutineContext'tir val context: CoroutineContext = element // Job oluşturma - coroutine'in yaşam döngüsünü kontrol eden bir context elementi val job: Job = Job() // Job da bir CoroutineContext.Element'tir val jobElement: CoroutineContext.Element = job // Ve bir CoroutineContext olarak da kullanılabilir val jobContext: CoroutineContext = jobElement // Farklı context elementlerini "+" operatörü ile birleştirme // Bu, her iki elementi de içeren yeni bir CoroutineContext oluşturur val ctx: CoroutineContext = name + job } //Örnek Sonu
CoroutineContext, daha basit bir şekilde oluşturulabilmesi için bileşik (composite) olarak uygulanmıştır. Bir yerdeCoroutineContext bekleniyorsa, tek bir öğeyi (element) doğrudan iletebilirsiniz; bunu bir koleksiyon içinesarmalamanıza gerek yoktur.
CoroutineContext olmasıdır. Ancak, birden fazla öğe iletmeniz gerekiyorsa, öğeleribirleştirerek ekleyebilirsiniz. Bu sayede oluşan
CoroutineContext, tüm öğeleri içeren bileşik bir yapı haline gelir./** * Farklı coroutine context'leri ile coroutine başlatma örnekleri: */ // Sadece CoroutineName context'i ile bir coroutine başlatır launch(CoroutineName("Name1")) { // Bu coroutine "Name1" olarak adlandırılır // Üst coroutine'in Job'ını miras alır // ... } // CoroutineName ve yeni bir Job içeren birleştirilmiş context ile coroutine başlatır launch(CoroutineName("Name2") + Job()) { // Bu coroutine "Name2" olarak adlandırılır // Kendi bağımsız Job'ına sahiptir (üst coroutine'den miras almaz) // ... }
CoroutineContext, bir koleksiyon yapısını temsil ettiğinden, belirli bir anahtar ile ilişkili bir öğeyi bulmak içinget fonksiyonu kullanılabilir.[]) de kullanılabilir. Bunun nedeni, Kotlin'de get fonksiyonunun bir operatörolarak tanımlanmış olmasıdır, bu sayede açıkça bir fonksiyon çağrısı yapmak yerine doğrudan köşeli parantezler ile
çağrılabilir.
Map üzerinden öğe almaya benzer şekilde çalışır:- Eğer ilgili öğe
CoroutineContextiçinde varsa, bu öğe döndürülür. - Eğer öğe bulunamazsa,
nulldöndürülür.
import kotlinx.coroutines.CoroutineName import kotlinx.coroutines.Job import kotlin.coroutines.CoroutineContext /** * CoroutineContext'ten belirli elementleri alıp sorgulama örneği */ //örnekBaşlangıcı fun main() { // Sadece bir CoroutineName elementinden oluşan bir CoroutineContext val ctx: CoroutineContext = CoroutineName("Bir isim") // Context'ten CoroutineName elementini alma val coroutineName: CoroutineName? = ctx[CoroutineName] // veya ctx.get(CoroutineName) şeklinde de yazılabilir println(coroutineName?.name) // Bir isim // Context'ten Job elementini almaya çalışma val job: Job? = ctx[Job] // veya ctx.get(Job) println(job) // null (çünkü context'te Job elementi yok) } //örnekSonu
CoroutineContext, Kotlin'in yerleşik eşzamanlı işlem desteğinin bir parçasıdır vekotlin.coroutinespaketinden
ithal edilir. Ancak,JobveyaCoroutineNamegibi bağlamlar (contextöğeleri)kotlinx.coroutineskütüphanesinin
bir parçasıdır, bu nedenlekotlinx.coroutinespaketinden ithal edilmeleri gerekir.
CoroutineName öğesini bulmak için doğrudan CoroutineName kullanılır. Bu, bir tür (type) veya sınıf (class)değildir, aksine bir companion objecttir. Kotlin’de bir sınıfın adı tek başına kullanıldığında, bu isim o sınıfın
companion nesnesine referans verir. Bu nedenle,
ctx[CoroutineName] ifadesi aslında ctx[CoroutineName.Key] ifadesininbir kısayoludur.
/** * Coroutine'lere isim atamak için kullanılan CoroutineContext elementi. Bu sınıf, * coroutine'lerin debugging ve loglama sırasında tanımlanmasını kolaylaştırır. */ data class CoroutineName( /** * Coroutine'e verilecek isim */ // AbstractCoroutineContextElement sınıfından türetilir ve anahtar olarak kendi companion object'ini kullanır val name: String ) : AbstractCoroutineContextElement(CoroutineName) { /** * Nesnenin string gösterimini özelleştirir * Örn: "CoroutineName(MeninCoroutine)" */ override fun toString(): String = "CoroutineName($name)" /** * Bu companion object, hem anahtar tipini tanımlar hem de CoroutineContext.Key * arayüzünü uygular. Bu sayede CoroutineName sınıfı, context'ten eleman almak * için kullanılabilir: ctx[CoroutineName] veya ctx.get(CoroutineName) şeklinde */ companion object Key : CoroutineContext.Key<CoroutineName> }
uygulamadır. Bu yaklaşım, bu öğelerin isimlerinin hatırlanmasını kolaylaştırır2Aşağıdaki eşlik eden nesne (companion object)
Key olarak adlandırılmıştır. Kotlin'de eşlik eden nesneler.key), bir sınıfa (class, örneğin CoroutineName) veya birçok sınıf tarafından paylaşılan bir arayüze(
interface, örneğin Job) işaret edebilir. Job ve SupervisorJob gibi farklı türler, aynı Job anahtarınıkullanarak
CoroutineContext içinde bulunabilir./** * Coroutine'lerin yaşam döngüsünü kontrol etmek için kullanılan arayüz. * Job, bir coroutine'in çalışmasını, iptal edilmesini ve tamamlanmasını yönetir. */ interface Job : CoroutineContext.Element { /** * Job arayüzünün companion object'i, CoroutineContext.Key arayüzünü uygular. * Bu sayede bir CoroutineContext'ten Job elementini almak için kullanılabilir: * coroutineContext[Job] veya coroutineContext.get(Job) şeklinde. */ companion object Key : CoroutineContext.Key<Job> // Job arayüzünün diğer metod ve özellikleri burada olacaktır. // Örneğin: cancel(), join(), isActive, isCompleted, onJoin, vb. // ... }
CoroutineContext yapısını gerçekten kullanışlı kılan şey, iki farklı bağlamın birleştirilebilmesidir. Farklıanahtarlara (
key) sahip iki öğe eklendiğinde, oluşan bağlam her iki anahtara da yanıt verebilir.import kotlinx.coroutines.CoroutineName import kotlinx.coroutines.Job import kotlin.coroutines.CoroutineContext // Örnek Başlangıcı fun main() { // İlk bağlam: CoroutineName ile bir bağlam oluşturuluyor val ctx1: CoroutineContext = CoroutineName("Name1") // "Name1" ekrana yazdırılır println(ctx1[CoroutineName]?.name) // null çünkü Job eklenmedi println(ctx1[Job]?.isActive) // İkinci bağlam: Job ile bir bağlam oluşturuluyor val ctx2: CoroutineContext = Job() // null çünkü CoroutineName eklenmedi println(ctx2[CoroutineName]?.name) // true çünkü Job varsayılan olarak "Active" durumda oluşturulur println(ctx2[Job]?.isActive) // İki bağlamı birleştirme: CoroutineName ve // Job içeren yeni bir bağlam oluşturuluyor val ctx3 = ctx1 + ctx2 // "Name1", çünkü ctx1 içinde vardı ve ctx3'e eklendi println(ctx3[CoroutineName]?.name) // true, çünkü ctx2 içinde bir Job vardı ve ctx3'e eklendi println(ctx3[Job]?.isActive) } // Örnek Sonu
mapde olduğu gibi, aynı anahtara (key) sahip başka bir öğe eklendiğinde, yeni öğe önceki öğenin yerinialır.
import kotlinx.coroutines.CoroutineName import kotlin.coroutines.CoroutineContext // Örnek Başlangıcı fun main() { // İlk CoroutineContext oluşturuluyor ve içine "Name1" etiketi ekleniyor. val ctx1: CoroutineContext = CoroutineName("Name1") // "Name1" çıktısını verir. println(ctx1[CoroutineName]?.name) // İkinci CoroutineContext oluşturuluyor ve içine "Name2" etiketi ekleniyor. val ctx2: CoroutineContext = CoroutineName("Name2") // "Name2" çıktısını verir. println(ctx2[CoroutineName]?.name) // İki bağlamı birleştiriyoruz. Ancak, CoroutineContext içinde aynı türde // bir öğe (aynı anahtara sahip CoroutineName) birden fazla kez bulunamaz. // Yeni eklenen öğe, önceki öğeyi değiştirir. val ctx3 = ctx1 + ctx2 // ctx3 içinde artık "Name1" değil, "Name2" yer alacaktır. // "Name2" çıktısını verir. println(ctx3[CoroutineName]?.name) } // Örnek Sonu
CoroutineContext bir koleksiyon gibi davrandığından, içerisinde herhangi bir öğe barındırmayan boş bir bağlam(context)da
bulunmaktadır. Bu bağlam (
EmptyCoroutineContext), tek başına kullanıldığında hiçbir öğe içermez. Ancak, başka birbağlama eklendiğinde, o bağlam üzerinde herhangi bir değişiklik yapmadan olduğu gibi davranır.
import kotlinx.coroutines.CoroutineName import kotlinx.coroutines.Job import kotlin.coroutines.CoroutineContext import kotlin.coroutines.EmptyCoroutineContext //Örnek Başlangıcı fun main() { // Boş bir CoroutineContext oluşturuluyor val empty: CoroutineContext = EmptyCoroutineContext // empty içinde CoroutineName elementi olmadığı için null çıktısı verir println(empty[CoroutineName]) // null // empty içinde Job elementi olmadığı için null çıktısı verir println(empty[Job]) // null // Boş context'e bir CoroutineName elementi eklenip, sonra tekrar boş context ekleniyor // EmptyCoroutineContext ile birleştirme işlemi mevcut context'i etkilemez val ctxName = empty + CoroutineName("Name1") + empty // Artık ctxName içinde CoroutineName elementi bulunduğu için // CoroutineName(Name1) çıktısı verir println(ctxName[CoroutineName]) //CoroutineName(Name1) } //Örnek Sonu
CoroutineContext) belirli bir öğeyi kaldırmak için minusKey fonksiyonu kullanılabilir. Bufonksiyon, belirtilen anahtara (
key) sahip olan öğeyi bağlamdan çıkarır ve kalan bağlamı döndürür.CoroutineContextiçinminusoperatörü (-) aşırı yüklenmemiştir. Bunun nedeni, bu operatörün anlamının
yeterince açık olmaması olabilir. Effective Kotlin kitabının "Madde 11: Bir operatörün anlamı, işleviyle tutarlı
olmalıdır" başlığında açıklandığı gibi, operatörün kullanım amacı net değilse aşırı yükleme önerilmez.
import kotlinx.coroutines.CoroutineName import kotlinx.coroutines.Job // Örnek Başlangıcı fun main() { // CoroutineContext içerisine "Name1" adıyla // bir CoroutineName ve aktif bir Job ekleniyor. val ctx = CoroutineName("Name1") + Job() // Çıktı: Name1 println(ctx[CoroutineName]?.name) // Çıktı: true (Job varsayılan olarak aktiftir) println(ctx[Job]?.isActive) // CoroutineContext'ten CoroutineName öğesini çıkarıyoruz. val ctx2 = ctx.minusKey(CoroutineName) // Çıktı: null (Çünkü CoroutineName kaldırıldı) println(ctx2[CoroutineName]?.name) // Çıktı: true (Job hala aktif) println(ctx2[Job]?.isActive) // Önce "Name2" adlı yeni bir CoroutineName ekleyip ardından kaldırıyoruz. val ctx3 = (ctx + CoroutineName("Name2")) .minusKey(CoroutineName) // Çıktı: null (CoroutineName kaldırıldığı için yok) println(ctx3[CoroutineName]?.name) // Çıktı: true (Job hala aktif) println(ctx3[Job]?.isActive) } // Örnek Sonu
fold yöntemini kullanabiliriz. Buyöntem, diğer koleksiyonlardaki
fold fonksiyonuna benzer şekilde çalışır ve şu parametreleri alır:- Başlangıç biriktirme değeri (initial accumulator value) – İşlem başlamadan önce kullanılan ilk değer.
- Güncellenmiş biriktirme değerini üreten işlem (operation) – Mevcut biriktirme değerini ve üzerinde işlem
yapılan öğeyi kullanarak bir sonraki durumu üretir.
CoroutineContext içindeki öğeleri sıralı olarak işleyerek belirli bir toplama işlemi gerçekleştirmeyeolanak tanır.
import kotlinx.coroutines.CoroutineName import kotlinx.coroutines.Job import kotlin.coroutines.CoroutineContext // Örnek Başlangıcı fun main() { // Bir CoroutineContext oluşturuyoruz: İçinde CoroutineName ve Job var val ctx = CoroutineName("Name1") + Job() // fold() kullanarak tüm öğeleri birleştiriyoruz ctx.fold("") { acc, element -> "$acc$element " } .also(::println) // ÇIKTI: CoroutineName(Name1) JobImpl{Active}@dbab622e // Açıklama: // - fold("") ile başlangıç değeri boş string ("") olarak belirlenir. // - Her element (CoroutineName, Job) sırayla acc'ye eklenir. // - Sonuç olarak tüm öğeler string olarak birleştirilir. // Boş bir CoroutineContext listesi oluşturuyoruz val empty = emptyList<CoroutineContext>() // fold() kullanarak, mevcut context'in tüm elemanlarını listeye ekliyoruz ctx.fold(empty) { acc, element -> acc + element } .joinToString() // Liste elemanlarını string olarak birleştiriyoruz .also(::println) // ÇIKTI: CoroutineName(Name1), JobImpl{Active}@dbab622e // Açıklama: // - fold(empty) ile başlangıç değeri boş bir liste olarak belirlenir. // - Her element (CoroutineName, Job) bu listeye eklenir. // - Sonuç olarak, context içindeki tüm elemanları içeren bir liste oluşur. // - joinToString() ile bu liste string haline getirilerek yazdırılır. } // Örnek Sonu
CoroutineContext, yalnızca veri tutma ve aktarma amacıyla kullanılan bir yapıdır. Varsayılan olarak, bir üst öğe (ebeveyn) bağlamını alt öğeye (çocuk) aktarır. Bu, ebeveyn-çocuk ilişkisinin etkilerinden biridir. Başka bir deyişle, bir
çocuk, bağlamını ebeveyninden devralır.
import kotlinx.coroutines.* // Örnek Başlangıcı // Eşzamanlı işlemler için loglama yapan yardımcı fonksiyon fun CoroutineScope.log(msg: String) { // Geçerli eşzamanlı işlem bağlamından isim alınıyor val name = coroutineContext[CoroutineName]?.name // "[İŞLEM_ADI] mesaj" formatında çıktı verilir println("[$name] $msg") } fun main(): Unit = runBlocking(CoroutineName("main")) { // "main" adlı bir eşzamanlı işlem başlatılır // [main] Started mesajı yazdırılır log("Started") // Yeni bir asenkron işlem başlatılır val v1 = async { // 500 milisaniye bekletilir delay(500) // [main] Running async mesajı yazdırılır log("Running async") // İşlem sonucu olarak 42 döndürülür 42 } // Yeni bir eşzamanlı işlem başlatılır launch { // 1000 milisaniye bekletilir delay(1000) // [main] Running launch mesajı yazdırılır log("Running launch") } // v1'in sonucunu bekler ve yazdırır -> [main] The answer is 42 log("The answer is ${v1.await()}") } // Örnek Sonu
devralınan bağlamı geçersiz kılar.
import kotlinx.coroutines.* // CoroutineScope içerisinde log mesajı yazdırmak için yardımcı fonksiyon // Coroutine bağlamından isim alarak mesajı formatlar fun CoroutineScope.log(msg: String) { // Mevcut coroutine'in ismi coroutineContext'ten alınır val name = coroutineContext[CoroutineName]?.name // İsim ve mesaj birleştirilerek yazdırılır println("[$name] $msg") } //örnek Başlangıcı fun main(): Unit = runBlocking(CoroutineName("main")) { // Ana coroutine "main" adıyla başlatılır // Ana coroutine'de log mesajı yazdırılır, [main] Started çıktısı verir log("Started") // "c1" adlı yeni bir coroutine async olarak başlatılır // Bu coroutine bir değer döndürecektir val v1 = async(CoroutineName("c1")) { // 500 milisaniye bekletilir delay(500) // c1 coroutine'inde log mesajı yazdırılır, [c1] Running async çıktısı verir log("Running async") // Bu coroutine'in sonucu olarak 42 değeri döndürülür 42 } // "c2" adlı başka bir coroutine başlatılır // Bu coroutine bir değer döndürmez launch(CoroutineName("c2")) { // 1000 milisaniye bekletilir delay(1000) // c2 coroutine'inde log mesajı yazdırılır, [c2] Running launch çıktısı verir log("Running launch") } // v1 async işleminin tamamlanmasını bekler ve sonucunu yazdırır // Ana coroutine'de log mesajı yazdırılır, [main] The answer is 42 çıktısı verir log("The answer is ${v1.await()}") } //örnek Sonu
// Bu ifade, bir coroutine'in nihai bağlamının (context) nasıl hesaplandığını gösterir defaultContext + parentContext + childContext // defaultContext: Coroutine oluşturucuları (launch, async, runBlocking vb.) // tarafından otomatik olarak sağlanan varsayılan bağlam öğeleri. // Örneğin, launch için bir varsayılan dispatcher. // parentContext: Üst (parent) coroutine'den miras alınan bağlam öğeleri. // Bir coroutine başka bir coroutine içinde oluşturulduğunda, üst coroutine'in // bağlamındaki öğeleri (Job hariç) otomatik olarak miras alır. // childContext: Coroutine oluşturulurken açıkça belirtilen özel bağlam öğeleri. // Örnek: launch(Dispatchers.IO + CoroutineName("worker")) ifadesindeki // Dispatchers.IO ve CoroutineName("worker") childContext'i oluşturur. // "+" operatörü burada bağlam öğelerinin birleştirilmesini temsil eder. // Aynı türden öğeler için, sağdaki öğe soldakini geçersiz kılar. // Yani childContext > parentContext > defaultContext önceliğe sahiptir.
ebeveyn bağlamındaki aynı anahtara sahip elemanları geçersiz kılar. Varsayılan bağlam değerleri ise yalnızca başka
hiçbir yerde belirtilmemiş anahtarlar için kullanılır.
Dispatchers.Default, başka birContinuationInterceptorbelirtilmediğinde varsayılan olarak atanır.CoroutineId, yalnızca uygulama hata ayıklama (debug) modundayken atanır ve bu, hata ayıklama sırasında işlem
kimliklerinin görüntülenmesini sağlar.
Job, geçerli işlemin durumunu yöneten özel bir bağlam elemanıdır.Ancak, diğer bağlam elemanlarının aksine, Jobebeveyn bağlamdan miras alınmaz, çünkü her işlem (coroutine) kendi bağımsız
Job nesnesine sahip olmalıdır. Bu konu,İş (Job) ve İşlem Yaşam Döngüsü bölümünde daha ayrıntılı olarak ele alınacaktır.
CoroutineScope, bağlama erişmek için kullanılabilecek coroutineContext adlı bir özelliğe sahiptir. Peki, eğer normalbir askıya alınabilir (suspending) fonksiyon içindeysek ne olur? Daha önce Coroutine'ler Derinlemesine bölümünde
açıklandığı gibi, bağlamlar devamlılık (continuation) nesneleriyle ilişkilidir ve her askıya alınabilir fonksiyon bir
devamlılık alır. Bu nedenle, ebeveyn bağlamına erişmek mümkündür. Bir askıya alınabilir fonksiyon içindeyken
coroutineContext özelliğini kullanarak geçerli bağlama erişebiliriz. Bu özellik, her askıya alınabilir kapsamda (suspending scope) mevcut durumdadır ve çağırıldığı yerin bağlamını sağlar.
import kotlinx.coroutines.* import kotlin.coroutines.coroutineContext // Askıya alınabilir bir fonksiyon olan printName(), // mevcut bağlamdan CoroutineName'i alıp adını ekrana yazdırır. suspend fun printName() { // Geçerli bağlamın adını ekrana yazdırır println(coroutineContext[CoroutineName]?.name) } fun main(): Unit = runBlocking( // Ana kapsam "Outer" bağlamı ile başlatılır CoroutineName("Outer") ) { // "Outer" yazdırılır çünkü printName() mevcut bağlamı kullanır. printName() // Yeni bir Coroutine başlatılır ve bağlam "Inner" olarak değiştirilir launch(CoroutineName("Inner")) { // "Inner" yazdırılır çünkü bu Coroutine "Inner" bağlamını kullanıyor. printName() } // Yeni başlatılan Coroutine'in çalışmasına zaman // tanımak için küçük bir gecikme eklenir. delay(10) // "Outer" yazdırılır çünkü hala ana kapsamdayız. printName() }
kapsamdan bağlamı devralır. Eğer bir
coroutineScope fonksiyonu, askıya alınabilir (suspend) bir fonksiyon içindeçağrılırsa, bu kapsamın başlattığı Coroutine, bu fonksiyonu başlatan Coroutine'in doğrudan bir alt öğesi olur. Böylece,
üst Coroutine'in bağlamını miras alır ve bu bağlamda çalışmaya devam eder.
import kotlinx.coroutines.* // Bu fonksiyon, mevcut coroutine bağlamından CoroutineName'i alıp // ekrana yazdırır coroutineScope kullanımı yeni bir coroutine // kapsamı oluşturur fakat ebeveyn bağlamını miras alır suspend fun printName() = coroutineScope { // coroutineContext, mevcut coroutine'in bağlamını temsil eden bir özelliktir // Bu bağlamdan CoroutineName alınıp adı (name) ekrana yazdırılır println(coroutineContext[CoroutineName]?.name) } // Ana coroutine "Outer" adlı bağlam ile başlatılır fun main(): Unit = runBlocking(CoroutineName("Outer")) { // "Outer" yazdırılır çünkü ana coroutine'in bağlamını miras alır printName() // Yeni bir coroutine "Inner" adlı bağlam ile başlatılır launch(CoroutineName("Inner")) { // "Inner" yazdırılır çünkü bu alt coroutine'in bağlamını miras alır printName() } // Yeni başlatılan coroutine'in çalışmasını // beklemek için kısa bir gecikme eklenir delay(10) // "Outer" yazdırılır çünkü hala ana coroutine kapsamındayız printName() }
withContext fonksiyonunukullanabilirsiniz. Bu fonksiyon,
coroutineScope ile benzer şekilde çalışır ancak oluşturduğu işlem birimi (coroutine)için bağlamı değiştirir. Askıya alınabilir bir fonksiyon olduğundan, başka askıya alınabilir fonksiyonlar içinde
kullanılabilir.
// Bu fonksiyon, dosya okuma işlemini IO thread havuzunda // gerçekleştiren askıya alınabilir (suspend) bir fonksiyondur suspend fun readSave() = withContext(Dispatchers.IO) { // IO işlemlerinin ana thread'i bloke // etmesini önlemek için Dispatchers.IO kullanılır // "save.txt" adlı dosyayı temsil eden bir File nesnesi oluşturulur val file = File("save.txt") // Dosyanın içeriği okunur ve string olarak döndürülür // Bu işlem potansiyel olarak uzun sürebilir, // bu yüzden IO dispatcher'da çalıştırılır file.readText() }
coroutineScope ile withContext arasındaki tek fark, withContext fonksiyonunun oluşturduğu işlem birimi içinbağlamı değiştirmesidir. Bu nedenle,
withContext(EmptyCoroutineContext) çağrıldığında, coroutineScope ile aynışekilde çalışır.
withContext fonksiyonu genellikle belirli bir işlem için özel bir bağlam tanımlamak amacıyla kullanılır.Bağlamların otomatik olarak iletildiğini unutmayın; yani, bir üst işlem biriminde tanımlanan bağlam,
alt işlem birimlerinde de geçerli olacaktır.
import kotlinx.coroutines.CoroutineName import kotlinx.coroutines.withContext import kotlin.coroutines.coroutineContext // Mevcut coroutine bağlamındaki CoroutineName'i yazdıran askıya alınabilir fonksiyon suspend fun printName() { // Coroutine bağlamından CoroutineName alınır ve ekrana yazdırılır // Eğer bağlamda CoroutineName tanımlanmamışsa null yazdırılır println(coroutineContext[CoroutineName]?.name) } // Ana fonksiyon - askıya alınabilir (suspend) olarak tanımlanmış suspend fun main() { // Bu noktada herhangi bir CoroutineName tanımlanmadığı için null yazdırılır printName() // null // a() fonksiyonu çağrılır a() } // "a" adında bir CoroutineName ile yeni bir coroutine bağlamı oluşturan fonksiyon suspend fun a() = withContext(CoroutineName("a")) { // Bu bağlamda CoroutineName "a" olarak tanımlandığı için "a" yazdırılır printName() // a // b() fonksiyonu çağrılır b() } // "b" adında bir CoroutineName ile yeni bir coroutine bağlamı oluşturan fonksiyon suspend fun b() = withContext(CoroutineName("b")) { // Bu bağlamda CoroutineName "b" olarak tanımlandığı için "b" yazdırılır printName() // b }
CoroutineContext.Element arayüzünü uygulayan bir sınıf oluşturmaktır. Bu tür bir sınıf, CoroutineContext.Key<*>türünde bir
key özelliğine sahip olmalıdır. Bu anahtar, bu bağlamın tanımlanmasını sağlar. Yaygın uygulama, bu sınıfıncompanion object öğesini anahtar olarak kullanmaktır. Aşağıda, basit bir işlem bağlamının nasıl oluşturulabileceği
gösterilmektedir:
// Özel bir coroutine bağlam öğesi tanımlayan sınıf class MyCustomContext : CoroutineContext.Element { // Her CoroutineContext.Element'in bir anahtar (key) değerine sahip // olması gerekir. Bu anahtar, coroutine bağlamında // bu öğeyi tanımlamak ve erişmek için kullanılır override val key: CoroutineContext.Key<*> = Key // Key sınıfı, hem companion object olarak hem de CoroutineContext. // Key implementasyonu olarak tanımlanmıştır Bu yapı, Kotlin'de // özel bağlam öğeleri oluşturmak için standart bir tasarım kalıbıdır companion object Key : CoroutineContext.Key<MyCustomContext> // Bu companion object sayesinde coroutineContext[MyCustomContext.Key] // şeklinde erişim sağlanabilir }
CoroutineName gibi davranacaktır:Ebeveynden çocuğa otomatik olarak aktarılacak, ancak altişlemler aynı anahtara sahip farklı bir bağlam ile bunu geçersiz kılabilecektir. Bunu pratikte görmek için, aşağıda
ardışık numaraları yazdırmak için tasarlanmış bir bağlam örneği bulunmaktadır.
import kotlinx.coroutines.launch import kotlinx.coroutines.withContext import kotlin.coroutines.CoroutineContext import kotlin.coroutines.coroutineContext // Sayaç verisi içeren özel bir coroutine bağlam öğesi class CounterContext( private val name: String ) : CoroutineContext.Element { // Bağlam öğesi için gerekli anahtar override val key: CoroutineContext.Key<*> = Key // Sayaç değeri private var nextNumber = 0 // Mevcut sayaç değerini yazdıran ve artıran fonksiyon fun printNext() { println("$name: $nextNumber") nextNumber++ } // Bu bağlam öğesini tanımlamak için kullanılan anahtar companion object Key : CoroutineContext.Key<CounterContext> } // Mevcut coroutine bağlamındaki CounterContext'i // kullanarak sayacı yazdıran fonksiyon suspend fun printNext() { // Coroutine bağlamından CounterContext alınır ve // varsa printNext() metodu çağrılır coroutineContext[CounterContext]?.printNext() } // Ana fonksiyon suspend fun main(): Unit = // "Outer" adlı bir CounterContext ile yeni bir coroutine başlatılır withContext(CounterContext("Outer")) { // İlk çağrı, "Outer" sayacı 0 yazdırır ve 1'e artırır printNext() // Outer: 0 // Yeni bir coroutine başlatılır ve // ebeveyn bağlamını (Outer CounterContext) devralır launch { // "Outer" sayacı 1 yazdırır ve 2'ye artırır printNext() // Outer: 1 // Bir alt coroutine daha başlatılır, ebeveyn bağlamını devralır launch { // "Outer" sayacı 2 yazdırır ve 3'e artırır printNext() // Outer: 2 } // "Inner" adlı yeni bir CounterContext ile yeni bir coroutine başlatılır launch(CounterContext("Inner")) { // "Inner" sayacı 0 yazdırır ve 1'e artırır printNext() // Inner: 0 // "Inner" sayacı 1 yazdırır ve 2'ye artırır printNext() // Inner: 1 // Bir alt coroutine daha başlatılır, // ebeveyn bağlamını (Inner CounterContext) devralır launch { // "Inner" sayacı 2 yazdırır ve 3'e artırır printNext() // Inner: 2 } } } // Ana coroutine'de "Outer" sayacı 3 yazdırır ve 4'e artırır printNext() // Outer: 3 }
kullanılabilir.
gelir: Bir eşzamanlı işlem belirli bir iş parçacığında başlatılabilir, daha sonra askıya alınabilir ve farklı bir iş
parçacığında devam ettirilebilir. Bu esneklik, Kotlin'in çoklu iş parçacığında verimli çalışmasını sağlarken, aynı
zamanda bazı sorunlara da yol açabilir. Özellikle, Java'daki bazı araçlar veriyi iş parçacıklarına özgü olarak saklar.
Örneğin, Java standart kütüphanesindeki
ThreadLocal veya Spring Boot'taki SecurityContext gibi yapılar, belirli biriş parçacığına bağlanarak veri tutar.Ancak, Kotlin’de eşzamanlı işlemler farklı iş parçacıklarında devam edebildiği
için, bu tür araçlarla uyumlu çalışmak zorlaşabilir.Bir eşzamanlı işlem başladığında bir iş parçacığında yer alan
veriler, işlem başka bir iş parçacığına geçtiğinde kaybolabilir veya tutarsız hale gelebilir.
ThreadContextElement adlı özel bir bağlam türü sunar.Bu bağlamı genişleten (extend eden) tüm nesneler, bir eşzamanlı işlem belirli bir iş parçacığında yeniden başlatıldığında, o iş parçacığınınbağlamına otomatik olarak eklenir.Böylece, bir eşzamanlı işlem farklı iş parçacıklarında çalıştırılsa bile, iş
parçacığına özgü veriler korunmuş olur.
ThreadLocal veya Spring Boot’un güvenlik bağlamı gibi iş parçacığı bağımlı yapıların, Kotlineşzamanlı işlemleriyle uyumlu hale getirilmesini sağlar.Yani, bir eşzamanlı işlem askıya alınıp başka bir iş
parçacığında devam ettiğinde, bu bağlam da o iş parçacığına taşınır ve önceki veriler korunmuş olur.
import kotlinx.coroutines.ThreadContextElement import kotlinx.coroutines.runBlocking import kotlin.coroutines.CoroutineContext // ThreadContextElement arayüzünü implemente eden bir sınıf tanımlıyoruz. // Bu sınıf, bir coroutine çalıştığında Thread'in adını değiştirmemizi sağlar. class CoroutineName( val name: String ) : ThreadContextElement<String> { // CoroutineContext içindeki CoroutineName // öğesinin anahtarını belirleyen companion object. companion object Key : CoroutineContext.Key<CoroutineName> // Bu nesnenin bağlamdaki anahtarını `Key` olarak belirliyoruz. override val key: CoroutineContext.Key<CoroutineName> = Key // Coroutine belirli bir iş parçacığında // devam etmeden hemen önce çağrılan fonksiyon. override fun updateThreadContext( context: CoroutineContext ): String { // Mevcut iş parçacığının adını kaydediyoruz. val previousName = Thread.currentThread().name // İş parçacığının adını güncelleyerek coroutine'in adını ekliyoruz. Thread.currentThread().name = "$previousName # $name" // Önceki adı döndürerek, sonradan geri yüklenmesini sağlıyoruz. return previousName } // Coroutine belirli bir iş parçacığında askıya alındığında çağrılan fonksiyon. override fun restoreThreadContext( context: CoroutineContext, oldState: String ) { // İş parçacığının adını eski haline getirerek // önceki duruma geri döndürüyoruz. Thread.currentThread().name = oldState } } // "MyCoroutine" adlı bir CoroutineName ile bir coroutine başlatıyoruz. // Bu sayede iş parçacığının adına "# MyCoroutine" eklenir. fun main(): Unit = runBlocking(CoroutineName("MyCoroutine")) { // "Running in thread: main # MyCoroutine" çıktısını verir. println("Running in thread: ${Thread.currentThread().name}") }
ThreadContextElement arayüzünün, bazı Spring Boot uygulamalarında güvenlik kontrolleri için kullanılanSecurityContext ile bir eşzamanlı işlemi ilişkilendirmek için nasıl kullanılabileceğini göstermektedir.SecurityContext, genellikle bir isteğe özel güvenlik verilerini korumak için kullanılır ve iş parçacığı değişse bilebu verilerin korunmasını sağlar. Bu bağlamın kullanılabilmesi için, bir eşzamanlı işlem başlatıldığında (
launchçağrıldığında)bu bağlamın iş parçacığına dahil edilmesi gerekmektedir3Riccardo Lippolis tarafından yazılan [*Spring SecurityContext'inizi Kotlin Coroutines ile. Bu yaklaşım, Spring Boot'un güvenlik
mekanizmasının Kotlin eşzamanlı işlemleri ile uyumlu şekilde çalışmasını sağlar.
// Spring Security güvenlik bağlamını coroutine'ler arasında aktarmak için // tasarlanmış özel bir coroutine bağlam öğesi ThreadContextElement arayüzünü // kullanarak, thread değiştiğinde güvenlik bilgilerinin korunmasını sağlar class SecurityCoroutineContext( // Varsayılan olarak mevcut güvenlik bağlamını kullanır private val securityContext: SecurityContext = SecurityContextHolder.getContext() ) : ThreadContextElement<SecurityContext?> { // Bu bağlam öğesinin anahtarını tanımlayan companion object companion object Key : Key<SecurityCoroutineContext> // Bu nesneyi bağlamdan almak için kullanılacak anahtar override val key: Key<SecurityCoroutineContext> = Key // Coroutine bir iş parçacığında çalışmaya başladığında güvenlik bağlamını ayarlar override fun updateThreadContext( context: CoroutineContext ): SecurityContext? { // Mevcut güvenlik bağlamını kaydeder val previousSecurityContext = SecurityContextHolder .getContext() // Başlangıçta belirtilen güvenlik bağlamını ayarlar SecurityContextHolder.setContext(securityContext) // Önceki bağlamı, yalnızca kimlik doğrulama bilgisi varsa döndürür // Bu sayede boş güvenlik bağlamları için gereksiz işlem yapılmaz return previousSecurityContext .takeIf { it.authentication != null } } // Coroutine çalışması askıya alındığında veya tamamlandığında önceki // güvenlik bağlamını geri yükler override fun restoreThreadContext( context: CoroutineContext, oldState: SecurityContext? ) { // Eğer önceki durum null ise, güvenlik bağlamını temizler if (oldState == null) { SecurityContextHolder.clearContext() } else { // Değilse, önceki güvenlik bağlamını geri yükler SecurityContextHolder.setContext(oldState) } } }
ThreadContextElement, bir eşzamanlı işlem içinde ThreadLocal kullanmak istediğimizde de kullanılır. ThreadLocaldoğrudan bir eşzamanlı işlemde kullanılamaz çünkü
ThreadLocal, belirli bir iş parçacığına bağlıdır, ancak bireşzamanlı işlem askıya alındığında farklı bir iş parçacığında devam edebilir.
asContextElement yöntemini sağlar. Bu yöntem, ThreadLocal nesnesini bir bağlam (context) öğesine dönüştürerek, eşzamanlı işlemin askıya alınması ve farklı bir iş parçacığında devam etmesi durumunda da
bu değişkenin korunmasını sağlar. Bu bağlam öğesi, içinde bulunduğu eşzamanlı işlem her tekrar başladığında iş parçacığı
bağlamına eklenir.Böylece, iş parçacığına bağlı olan
ThreadLocal, eşzamanlı işlemlere özgü bir değişkene dönüşmüşolur.
import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.asContextElement import kotlinx.coroutines.withContext // Thread'e özgü bir String değeri saklayacak bir ThreadLocal tanımlıyoruz val id = ThreadLocal<String?>() suspend fun main(): Unit = withContext(Dispatchers.Default) { // ThreadLocal değerini okuyoruz, henüz hiçbir değer atanmadığı için null println(id.get()) // null // ThreadLocal değerini "A" olarak ayarlayan özel bir coroutine // bağlam öğesiyle yeni bir coroutine başlatıyoruz withContext(id.asContextElement("A")) { // Bu coroutine içinde ThreadLocal değerine erişiyoruz, // değer "A" olarak ayarlanmış println(id.get()) // A // Thread havuzunu değiştiren başka bir dispatcher // kullanarak yeni bir coroutine başlatıyoruz withContext(Dispatchers.IO) { // Farklı bir thread'de çalışmasına rağmen, ThreadLocal değeri korunuyor println(id.get()) // A } } // Önceki coroutine kapsamından çıktığımızda, // ThreadLocal değeri tekrar null oluyor println(id.get()) // null }
kotlinx-coroutines-slf4j kütüphanesinde bulunan MDCContext öğesidir. Bu öğe, SLF4J kütüphanesindengelen Mapped Diagnostic Context (MDC) bilgisini yaymak için kullanılır. MDC, özellikle loglama süreçlerinde bağlamsal
bilgileri korumak ve taşımak için kullanılan bir mekanizmadır.
MDCContext, eşzamanlı işlemler arasında bu bağlamsalbilgilerin korunmasını ve aktarılmasını sağlar.
// MDC (Mapped Diagnostic Context) bilgilerini coroutine'ler // arasında taşıyan özel bir bağlam ile coroutine başlatıyoruz launch(MDCContext()) { // MDC'ye bir anahtar-değer çifti ekliyoruz // MDC, loglamada kullanılan ve thread yerel bir harita sunan bir yapıdır MDC.put("key", "value") // Bu güncelleme kaydedilecektir. // Yeni bir MDCContext ile alt coroutine başlatıyoruz // Bu, mevcut MDC değerlerinin bir kopyasını alıp yeni bağlama aktarır withContext(MDCContext()) { // Coroutine'i 1 saniye askıya alıyoruz // Bu sırada thread değişse bile MDC değerleri korunacaktır delay(1000) // MDC'den "key" anahtarının değerini alıp yazdırıyoruz Farklı bir // thread'de çalışıyor olsa bile, MDCContext sayesinde değer korunuyor println(MDC.get("key")) // Bu, "value" çıktısını verecektir. } }
doğrudan kullanılmaları önerilmez. Ancak, eski (legacy) kütüphanelerle veya henüz eşzamanlı işlemlere geçirilmemiş
uygulama bölümleriyle uyumluluk sağlamak için kullanılması gerekebilir. Tüm bu araçlar, çok daha basit ve hafif
eşzamanlı işlem bağlamları ile değiştirilebilir.
import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.withContext import kotlin.coroutines.AbstractCoroutineContextElement import kotlin.coroutines.CoroutineContext import kotlin.coroutines.coroutineContext // Coroutine bağlamına eklenebilecek özel bir bağlam öğesi tanımlıyoruz // Bu sınıf, coroutine'lerin bir kimlik taşımasını sağlayacak class MyId(val id: String) : AbstractCoroutineContextElement(MyId) { // Bu bağlam öğesini coroutine bağlamından almak için kullanılacak anahtar companion object Key : CoroutineContext.Key<MyId> } // Mevcut coroutine bağlamından MyId'yi alıp id özelliğini döndüren bir // yardımcı fonksiyon Bu fonksiyon, çağrıldığı coroutine'nin bağlamına // erişerek MyId değerini sorgular suspend fun getId() = coroutineContext[MyId]?.id suspend fun main(): Unit = withContext(Dispatchers.Default) { // "A" değerine sahip bir MyId nesnesi oluşturuyoruz val id = MyId("A") // Bu noktada, coroutine bağlamında henüz // MyId öğesi olmadığı için null sonucu alırız println(getId()) // null // MyId bağlam öğesini içeren yeni bir coroutine başlatıyoruz withContext(id) { // Bu coroutine'in bağlamı MyId içerdiği için "A" değerini alırız println(getId()) // A // Farklı bir dispatcher ile yeni bir coroutine başlatıyoruz // Ancak üst coroutine'in bağlam öğeleri (MyId dahil) alt coroutine'e aktarılır withContext(Dispatchers.IO) { // Farklı bir thread'de çalışmasına rağmen, MyId değeri korunur println(getId()) // A } } // withContext kapsamından çıktıktan sonra, MyId artık // bağlamda olmadığı için tekrar null alırız println(getId()) // null }
CoroutineContext, kavramsal olarak bir Map veya Set koleksiyonuna benzer şekilde tasarlanmış, her bir bileşeninkendine özgü bir
Key ile tanımlandığı, indekslenmiş bir yapı sunar. Eşzamanlı işlem birimlerine nesne gruplama veiletme mekanizması sağlayarak, bu nesnelerin çalışma sürecini, durumlarını ve hangi iş parçacığında yürütüleceklerini
belirler. Üst işlem biriminden miras alınan bağlam, alt işlem birimlerinde üzerine yazılabilir ve tüm işlem birimi
hiyerarşisi boyunca yayılım göstererek, bağlamın her seviyede erişilebilir olmasını sağlar. Birçok gelişmiş kullanım
senaryosunda bağlamın yönetimi kritik bir rol oynar. Sonraki bölümlerde, bağlamın en yaygın kullanılan bileşenlerinden
biri olan işleyiciler (
Dispatchers) ayrıntılı olarak ele alınacaktır.- 1.Terminolojiyi netleştirelim.
launchfonksiyonu,CoroutineScopeüzerinde tanımlanmış bir genişletme (* ↩ - 2.Aşağıdaki eşlik eden nesne (companion object)
Keyolarak adlandırılmıştır. Kotlin'de eşlik eden nesneler ↩ - 3.Riccardo Lippolis tarafından yazılan [*Spring SecurityContext'inizi Kotlin Coroutines ile ↩