Kotlin Coroutines'ta Job ve Alt Görevlerin Yönetimi

Kotlin Coroutines'ta Job ve Alt Görevlerin Yönetimi

Bu metin, Kotlin Coroutines kitabının bir bölümüdür. Kitabın tamamına LeanPub üzerinden erişebilirsiniz
Bir coroutine askıya alındığında, geriye yalnızca onun devam nesnesi (continuation) kalır. Bu nesne, yerel değişkenlere
olan referansları, her askıya alınan fonksiyonun durduğu yerleri belirten etiketleri ve bu coroutine'in bağlamını
içerir. Hepsi bu kadardır. Ancak coroutineler bundan daha fazla bilgiye ihtiyaç duyar: durumlarını, ilişkilerini (
ebeveyn ve çocuk coroutineler) ve daha fazlasını bilmeleri gerekir. İşte bu bilgileri özel bir bağlamda, yani Job içinde
tutarlar.
Job, her coroutine'in en önemli bağlamıdır. Her coroutine'in kendi job bileşeni bulunur ve bu, ebeveynden miras
alınamayan tek bağlamdır. Bunun sebebi, her coroutine'in kendi durumu ve ilişkileri olmasıdır; dolayısıyla, Job
paylaşılamaz. Job, dışarıdan atanamaz, çünkü her coroutine oluşturucusu kendi job bileşenini oluşturmalı ve kontrol
etmelidir.
Job, Job arayüzünü (interface) uygulayan bir bağlamdır ve Job anahtarı (key) ile tanımlanır. İptal edilebilir
ve bir yaşam döngüsüne sahiptir. Aynı zamanda bir durumu vardır ve bu durum kullanılarak bir coroutine iptal
edilebilir, tamamlanması beklenebilir ve daha pek çok işlem yapılabilir. Job oldukça önemli bir bileşendir, bu
yüzden bu bölüm onun nasıl çalıştığını ele almaktadır.

Job ve Coroutine İlişkileri

Her coroutine, bağlamında Job anahtarı kullanılarak erişilebilen kendi job bileşenine sahiptir.
import kotlinx.coroutines.* // Ana fonksiyon - runBlocking ile bir coroutine scope oluşturur // runBlocking, fonksiyon tamamlanana kadar mevcut thread'i // bloke eden bir coroutine builder'dır fun main(): Unit = runBlocking { // Mevcut coroutine bağlamından Job nesnesini alır ve // aktif olup olmadığını kontrol eder // runBlocking kendisi bir Job oluşturduğu için, bu Job aktif durumdadır // Bu sebeple konsola "true" yazdırır print(coroutineContext[Job]?.isActive) // true }
Coroutine'lerin job bileşenine daha kolay erişmemizi sağlayan bir genişletme fonksiyonu olan job da bulunmaktadır.
import kotlinx.coroutines.* import kotlin.coroutines.* // CoroutineContext sınıfı için bir genişletme özelliği tanımlıyoruz // Bu, herhangi bir CoroutineContext nesnesine "job" özelliği ekler val CoroutineContext.job: Job // Özellik erişildiğinde çalışacak get() metodu get() = get(Job) ?: error("Mevcut context-bağlam içerisinde Job elementi bulunmamaktadır") // Bağlamdan Job elementini alır // Eğer Job yoksa (null dönerse), anlamlı bir hata mesajı ile programı sonlandırır // Genişletme özelliğinin kullanımını gösteren örnek fun main(): Unit = runBlocking { // runBlocking bir coroutine başlatır ve kendi Job'ını oluşturur // coroutineContext.job ifadesi, yukarıda tanımladığımız genişletme özelliğini kullanır // isActive, Job'ın aktif olup olmadığını kontrol eder (bu durumda true) print(coroutineContext.job.isActive) // true döner çünkü yeni başlatılan coroutine aktiftir }
Asenkron coroutine oluşturucuları kendi job bileşenlerini döndürür, böylece başka yerlerde kullanılabilirler. Bu durum,
launch fonksiyonunda açıkça görülebilir, çünkü Job burada doğrudan dönen bir sonuç türüdür.
import kotlinx.coroutines.* // Ana fonksiyon tanımlanıyor, runBlocking ile coroutine kapsamı oluşturuluyor fun main(): Unit = runBlocking { // launch ile yeni bir coroutine başlatılıyor ve dönen Job referansı job değişkenine atanıyor val job: Job = launch { // Coroutine içinde 1 saniye bekleniyor delay(1000) // Bekleme tamamlandıktan sonra "Test" yazısı yazdırılıyor println("Test") } // Not: job değişkeni tanımlanıyor ama hiçbir işlem yapılmıyor // runBlocking, içindeki tüm coroutine'lerin tamamlanmasını bekleyeceği için // "Test" yazısı 1 saniye sonra yazdırılacak ve ardından program sonlanacak }
async fonksiyonunun döndürdüğü tür Deferred<T> olup, aynı zamanda Job arayüzünü uygular.
import kotlinx.coroutines.* fun main(): Unit = runBlocking { // Bir değer döndürebilen ve ertelenmiş bir coroutine oluşturulur val deferred: Deferred<String> = async { // Coroutine 1 saniye bekler delay(1000) // Coroutine'in dönüş değeri "Test" olacaktır "Test" } // Deferred nesnesi bir Job nesnesine atanır (tür dönüşümü) val job: Job = deferred }
Job, bir coroutine'in başka bir coroutine'den devralmadığı tek coroutine bağlamıdır. Her coroutine kendi Job
bileşenini oluşturur ve bir argümandan veya üst coroutine'den gelen Job, bu yeni Job bileşeninin ebeveyni olarak
atanır1.
import kotlinx.coroutines.* fun main(): Unit = runBlocking { // "Some name" adında bir coroutine ismi oluşturulur val name = CoroutineName("Some name") // Yeni bir Job nesnesi oluşturulur val job = Job() // name ve job birleştirilerek yeni bir CoroutineContext // oluşturulur ve launch için parametre olarak kullanılır launch(name + job) { // Mevcut coroutine bağlamından CoroutineName elementini alır val childName = coroutineContext[CoroutineName] // Alınan ismin, üst coroutine'de tanımlanan // name ile aynı olup olmadığını kontrol eder println(childName == name) // true - isim aynen miras alınır // Mevcut coroutine bağlamından Job elementini alır val childJob = coroutineContext[Job] // Alınan Job'ın, üst coroutine'de tanımlanan // job ile aynı olup olmadığını kontrol eder println(childJob == job) // false - yeni bir Job nesnesi oluşturulur // Alınan Job'ın, üst Job'ın ilk çocuğu olup olmadığını kontrol eder println(childJob == job.children.first()) // true - üst Job'ın çocuğudur } }
Üst coroutine, tüm alt coroutineleri referans alabilir ve alt coroutineler de üst coroutine'ini referans gösterebilir.
Bu üst-alt coroutine ilişkisi, bir coroutine kapsamı içinde iptal mekanizmasının ve istisna yönetiminin uygulanmasını
sağlar. Çoğu durumda, Job, bir coroutine oluşturucusunun kapsamı içinde örtük olarak iletilir. Aşağıdaki örnekte
olduğu gibi, runBlocking, launch coroutine'inin üst coroutine'idir çünkü launch, runBlocking tarafından sağlanan
kapsam içinde kendi Job bileşenini bulabilir.
import kotlinx.coroutines.* fun main(): Unit = runBlocking { // Mevcut coroutine bağlamından ebeveyn (üst) Job'ı alır val parentJob: Job = coroutineContext.job // Yeni bir coroutine başlatır ve onun Job'ını kaydeder val job: Job = launch { // Coroutine 1 saniye bekler delay(1000) } // Karşılaştırma 1: job ve parentJob aynı değildir println(job == parentJob) // false // Karşılaştırma 2: parentJob'ın ilk çocuğu job'dır println(parentJob.children.first() == job) // true // Karşılaştırma 3: job'ın ebeveyni parentJob'dır println(job.parent == parentJob) // true }
Yeni bir Job bağlamı, üst coroutine'den gelen Job bileşeninin yerine geçerse, yapılandırılmış eşzamanlılık (
structured concurrency) mekanizmaları çalışmaz.
import kotlinx.coroutines.* // Ana coroutine başlar fun main(): Unit = runBlocking { // Önemli nokta: launch içine Job() parametresi geçiyoruz // Yeni bir coroutine başlatılıyor ama tamamen bağımsız bir Job ile launch(Job()) { // Bu coroutine'in runBlocking ile hiçbir bağlantısı yok artık delay(1000) // 1 saniye bekle // Bu satır asla çalışmayacak println("Bu satır yazdırılmayacak") } // runBlocking bloğunun sonu - kendi Job'ına bağlı // coroutine'ler olmadığı için hemen çıkar }
Yukarıdaki örnekte, runBlocking, launch coroutine'ini beklemez çünkü aralarında bir ilişki yoktur. Bunun nedeni,
launch fonksiyonunun, argüman olarak verilen Job bileşenini üst coroutine olarak kullanmasıdır. Bir coroutine
kendi (bağımsız) Job bileşenine sahipse, üst coroutine ile neredeyse hiçbir ilişkisi kalmaz. Diğer bağlamları miras
alır, ancak üst-alt coroutine ilişkisine bağlı diğer sonuçlar geçerli olmaz. Bu durum, yapılandırılmış eşzamanlılığın (
structured concurrency) kaybolmasına neden olur ve kaçınılması gereken bir sorundur.

Coroutine Yaşam Döngüsü

Her coroutine, job bileşeni tarafından yönetilen kendi durumuna sahiptir. Durum yaşam döngüsü, iptal ve eşzamanlama
(synchronization) gibi temel coroutine mekanizmaları için kritik öneme sahiptir. İşte coroutine durumlarını ve
bunlar arasındaki geçişleri gösteren bir grafik:

Job (dolayısıyla coroutine) durumlarını gösteren bir diyagram.
.
"Active" (Etkin) durumunda bir job çalışır. Eğer job bir coroutine oluşturucu ile başlatılmışsa, coroutine'in gövdesi
bu durumda yürütülür. Bu durumda, alt coroutineler başlatılabilir. Çoğu coroutine, doğrudan "Active" durumunda başlar.
Yalnızca tembel (lazy) başlatılan coroutineler "New" (Yeni) durumunda başlar ve "Active" durumuna geçmek için açıkça
start metodu kullanılarak başlatılmaları gerekir. Bir coroutine'in gövdesi yürütüldüğünde, kesin olarak "Active"
durumundadır. Gövdenin yürütülmesi tamamlandığında, coroutine "Completing" (Tamamlanıyor) durumuna geçer ve çocuklarının
tamamlanmasını bekler. Tüm çocuklar tamamlandığında, coroutine "Completed" (Tamamlandı) durumuna geçer; bu, bir son
durumdur.
Alternatif olarak, eğer bir job "Active" veya "Completing" durumundayken iptal edilirse veya bir hata oluşursa, durumu
"Cancelling" (İptal) olarak değişir. Bu aşamada, bağlantıları kapatma veya kaynakları serbest bırakma gibi
temizleme işlemleri gerçekleştirilebilir (bunun nasıl yapılacağını sonraki bölümde ele alacağız). Temizleme işlemi
tamamlandığında, job "Cancelled" (İptal Edildi) durumuna geçer.
Bir job'un durumu, toString metodunda gösterilir2. Aşağıdaki örnekte, farklı job'ların durum değişimlerini
görüyoruz. Son job, tembel (lazy) başlatılmıştır, yani otomatik olarak başlamaz. Diğer tüm job'lar oluşturulduklarında
hemen etkin hale gelir.
import kotlinx.coroutines.* // Suspend fonksiyon olarak main tanımlanıyor, coroutineScope içinde çalışacak suspend fun main(): Unit = coroutineScope { // BÖLÜM 1: Manuel Job oluşturma // Yeni bir Job nesnesi oluşturuyoruz - başlangıçta aktif durumda val job = Job() // Job'ın durumunu yazdırıyoruz - Aktif olduğunu göreceksiniz println(job) // JobImpl{Active}@ADD // Job'ı tamamlamak için complete() metodunu çağırıyoruz job.complete() // Job'ın durumu artık Completed (Tamamlandı) olacak println(job) // JobImpl{Completed}@ADD // BÖLÜM 2: Normal başlatılan bir coroutine // launch ile yeni bir coroutine başlatıyoruz - varsayılan olarak HEMEN aktif olur val activeJob = launch { // Bu coroutine 1 saniye bekleyecek delay(1000) } // Coroutine'in durumunu yazdırıyoruz - Aktif olduğunu göreceksiniz println(activeJob) // StandaloneCoroutine{Active}@ADD // join() ile coroutine tamamlanana kadar bekliyoruz // Bu 1 saniye sürecek çünkü içinde delay(1000) var activeJob.join() // (1 saniye) // Coroutine artık tamamlandı, durumunu yazdırıyoruz println(activeJob) // StandaloneCoroutine{Completed}@ADD // BÖLÜM 3: Lazy (tembel) başlatılan bir coroutine // LAZY mod ile başlatılan coroutine hemen çalışmaz val lazyJob = launch(start = CoroutineStart.LAZY) { // Bu kod ancak start() çağrıldığında çalışmaya başlar delay(1000) } // Coroutine'in durumunu yazdırıyoruz - henüz başlamamış olduğunu göreceksiniz println(lazyJob) // LazyStandaloneCoroutine{New}@ADD // start() ile coroutine'i manuel olarak başlatıyoruz lazyJob.start() // Coroutine şimdi Aktif duruma geçti println(lazyJob) // LazyStandaloneCoroutine{Active}@ADD // join() ile coroutine tamamlanana kadar bekliyoruz // Bu 1 saniye sürecek çünkü içinde delay(1000) var lazyJob.join() // (1 saniye) // Coroutine artık tamamlandı, durumunu yazdırıyoruz println(lazyJob) // LazyStandaloneCoroutine{Completed}@ADD }
Kod içinde durumu kontrol etmek için isActive, isCompleted ve isCancelled özelliklerini kullanırız.
DurumisActiveisCompletedisCancelled
New (isteğe bağlı başlangıç durumu)falsefalsefalse
Active (varsayılan başlangıç durumu)truefalsefalse
Completing (geçici durum)truefalsefalse
Cancelling (geçici durum)falsefalsetrue
Cancelled (son durum)falsetruetrue
Completed (son durum)falsetruefalse
Job arayüzü, job ile etkileşime geçmek için kullanabileceğimiz bazı yararlı fonksiyonlar sunar. Bunlardan biri olan
join, bir job'un tamamlanmasını beklemek için kullanılır.

Job'un Tamamlanmasını Bekleme

Bir coroutine'in job bileşeni, tamamlanana kadar beklemek için kullanılabilir. Bunu gerçekleştirmek için,
belirli bir job'un son durumuna ("Cancelled" veya "Completed") ulaşana kadar askıya alınmasını sağlayan
join metodunu kullanırız.
import kotlinx.coroutines.* // Ana fonksiyon tanımlanıyor, runBlocking ile // bir coroutine kapsamı oluşturuluyor fun main(): Unit = runBlocking { // İlk coroutine başlatılıyor ve job1 değişkenine atanıyor val job1 = launch { delay(1000) // 1 saniye bekle println("Test1") // Beklemeden sonra "Test1" yazdır } // İkinci coroutine başlatılıyor ve job2 değişkenine atanıyor val job2 = launch { delay(2000) // 2 saniye bekle println("Test2") // Beklemeden sonra "Test2" yazdır } // job1'in tamamlanmasını bekle // NOT: Her iki job da zaten paralel olarak çalışıyor olacak job1.join() // job2'nin tamamlanmasını bekle job2.join() // Tüm job'lar tamamlandıktan sonra çalışacak kod println("Tüm testler tamamlandı") } // Program çalışma sırası: // - Her iki job da hemen başlar // - (1 saniye sonra) job1 tamamlanır ve "Test1" yazdırılır // - (1 saniye daha, toplam 2 saniye sonra) // job2 tamamlanır ve "Test2" yazdırılır // - Hemen ardından "Tüm testler tamamlandı" yazdırılır
Job arayüzü, tüm alt job bileşenlerine referans vermemizi sağlayan children özelliğini de sunar. Bu özelliği,
tüm alt job'ların son durumuna ulaşmasını beklemek için de kullanabiliriz.
import kotlinx.coroutines.* // Ana fonksiyon, runBlocking ile bir coroutine kapsamı başlatıyor fun main(): Unit = runBlocking { // İlk coroutine başlatılıyor, referans tutulmuyor launch { delay(1000) // 1 saniye bekle println("Test1") // 1 saniye sonra yazdır } // İkinci coroutine başlatılıyor, referans tutulmuyor launch { delay(2000) // 2 saniye bekle println("Test2") // 2 saniye sonra yazdır } // Mevcut coroutineContext'ten Job alınır ve // bu Job'a bağlı çocuk job'ların listesine erişilir val children = coroutineContext[Job] ?.children // Çocuk job sayısı hesaplanır (2 adet launch olduğu için 2) val childrenNum = children?.count() // Alt job sayısını yazdır println("Alt job sayısı: $childrenNum") // Tüm çocuk job'ların tamamlanmasını bekle // Her bir çocuk job için join() çağrılır children?.forEach { it.join() } // Tüm çocuk job'lar tamamlandıktan sonra çalışır println("Tüm testler tamamlandı") } // Program çalışma sırası: // - Önce "Alt job sayısı: 2" yazdırılır // - (1 saniye sonra) "Test1" yazdırılır // - (1 saniye daha sonra) "Test2" yazdırılır // - Hemen ardından "Tüm testler tamamlandı" yazdırılır
Coroutineleri eşzamanlı hale getirmek için join metodunun kullanılması yaygın bir durumdur. Aşağıdaki örneği ele
alalım: Tamamlanması gereken bir siparişimiz var. Siparişi oluşturmalı, faturayı düzenlemeli, siparişi teslim etmeli ve
bir e-posta göndermeliyiz.
  • Siparişin fatura olarak işaretlenmeden önce oluşturulduğundan emin olmak istiyoruz.
  • Faturanın oluşturulmadan önce siparişin teslim edilmediğinden emin olmak istiyoruz.
  • Siparişin hem faturalandırılmış hem de teslim edilmiş olarak işaretlenmeden önce e-postanın gönderilmediğinden emin
    olmak istiyoruz.
Bu işlemleri eşzamanlı hale getirmek için join metodunu kullanabiliriz.
// completeOrder function (Sipariş tamamlama fonksiyonu) suspend fun completeOrder(order: Order) = coroutineScope { // createOrderJob coroutine (Sipariş oluşturma coroutine'i) val createOrderJob = launch { // createOrder service call (Sipariş oluşturma servis çağrısı) orderService.createOrder(order) } // invoiceJob coroutine (Fatura coroutine'i) val invoiceJob = launch { // createInvoice and get invoiceId (Fatura oluştur ve ID al) val invoiceId = invoiceService.createInvoice(order) // join createOrderJob (Sipariş oluşturma işinin bitmesini bekle) createOrderJob.join() // markOrderAsInvoiced (Siparişi faturalandı olarak işaretle) orderService.markOrderAsInvoiced(order, invoiceId) } // deliveryJob coroutine (Teslimat coroutine'i) val deliveryJob = launch { // orderDelivery and get deliveryId (Teslimat sipariş et ve ID al) val deliveryId = deliveryService.orderDelivery(order) // join invoiceJob (Fatura işinin tamamlanmasını bekle) invoiceJob.join() // markOrderAsDelivered (Siparişi teslim edildi olarak işaretle) orderService.markOrderAsDelivered(order, deliveryId) } // join invoiceJob (Fatura işinin tamamlanmasını bekle) invoiceJob.join() // join deliveryJob (Teslimat işinin tamamlanmasını bekle) deliveryJob.join() // sendEmail at the end (Tüm işlemler sonunda e-posta gönder) sendEmail(order) }
join kullanmak yerine, bir coroutine'in sonucunu beklemek için async fonksiyonundan await metodunu da
kullanabilirsiniz. Tek fark, await coroutine'in sonucunu döndürürken, join metodunun Unit döndürmesidir.

Job Fabrika Fonksiyonu

Bir coroutine olmadan da Job() fabrika fonksiyonunu kullanarak bir Job oluşturulabilir. Job() fonksiyonu, herhangi
bir coroutine ile ilişkilendirilmemiş bir job oluşturur ve bu job bir bağlam olarak kullanılabilir. Bu, aynı zamanda bu
job'un birçok coroutine için üst job olarak kullanılabileceği anlamına gelir. Ancak, böyle bir job'u üst job olarak
kullanmak karmaşık olabilir ve bunu yapmaktan kaçınılması önerilir.
Yaygın bir hata, Job() fabrika fonksiyonunu kullanarak bir job oluşturmak, ardından bunu bazı coroutine'ler için üst
job olarak kullanmak ve son olarak bu job üzerinde join metodunu çağırmaktır. Böyle bir program asla sona
ermeyecektir, çünkü Job bileşeni, tüm alt coroutine'ler tamamlanmış olsa bile hâlâ "Active" durumundadır. Bunun
nedeni, bu bağlamın başka coroutine'ler tarafından kullanılmaya devam edebilecek olmasıdır.
import kotlinx.coroutines.* // ana coroutine fonksiyonu suspend fun main(): Unit = coroutineScope { // Yeni bir Job oluştur val job = Job() // İlk launch özel job ile launch(job) { // 1 saniye bekle delay(1000) // Metin 1'i yazdır println("Metin 1") } // İkinci launch aynı job ile launch(job) { // 2 saniye bekle delay(2000) // Metin 2'i yazdır println("Metin 2") } // Job'ın tamamlanmasını bekle job.join() // Bu satır hiç çalışmaz println("Bu satır yazdırılmayacak") } // Çalışma akışı: // - 1 saniye sonra: "Metin 1" // - 1 saniye daha sonra: "Metin 2" // - Program sonsuza kadar asılı kalır
Daha iyi bir yaklaşım, job'un mevcut tüm alt job'larını beklemek için join metodunu kullanmaktır.
import kotlinx.coroutines.* // ana coroutine fonksiyonu suspend fun main(): Unit = coroutineScope { // Yeni bir Job oluştur val job = Job() // İlk launch özel job ile launch(job) { // 1 saniye bekle delay(1000) // Metin 1'i yazdır println("Metin 1") } // İkinci launch aynı job ile launch(job) { // 2 saniye bekle delay(2000) // Metin 2'i yazdır println("Metin 2") } // Job'ın tüm alt görevlerini bekle job.children.forEach { it.join() } } // Çalışma akışı: // - 1 saniye sonra: "Metin 1" // - 1 saniye daha sonra: "Metin 2"
Job() fonksiyonu, sahte yapıcı (fake constructor) desenine bir örnektir3. İlk bakışta Job'un yapıcısını
(constructor) çağırdığınızı düşünebilirsiniz, ancak Job bir arayüz (interface) olduğundan yapıcıya sahip olamaz.
Gerçekte, Job bir yapıcı gibi görünen basit bir fonksiyondur. Ayrıca, bu fonksiyonun döndürdüğü tür doğrudan bir
Job değil, onun alt arayüzü (subinterface) olan CompletableJob türüdür.
public fun Job(parent: Job? = null): CompletableJob // Bu fonksiyon yeni bir CompletableJob nesnesi oluşturur. // Parametreler: // - parent: Job? = null: İsteğe bağlı bir üst (parent) Job parametresi. // Varsayılan değeri null'dır. Eğer belirtilirse, oluşturulan Job // bu parent'a bağımlı olur ve parent iptal edildiğinde bu Job da iptal edilir. // // Dönüş Değeri: // - CompletableJob: Bu, programatik olarak tamamlanabilen özel bir Job türüdür. // Normal bir Job'ın tüm özelliklerine sahiptir, ancak ayrıca aşağıdaki // metodları da içerir: // * complete(): Job'ı başarıyla tamamlar // * completeExceptionally(exception): Job'ı bir hata ile tamamlar // // Notlar: // - Job() ile oluşturulan bir Job, manuel olarak complete() çağrılmadığı // sürece asla tamamlanmaz // - Job iptal edilebilir: cancel() çağrılarak // - Job beklenebilir: join() çağrılarak // - Job'ın alt görevleri (children) olabilir ve bunlara erişilebilir
CompletableJob arayüzü, Job arayüzünün işlevselliğini genişleterek iki ek metot sağlar:
  • complete(): Boolean - Bu metot, job'un durumunu "Completing" olarak değiştirmek için kullanılır. Bu durumda job,
    tüm alt job'larının tamamlanmasını bekler; alt job'lar tamamlandığında ise durumu "Completed" olarak güncellenir.
    Bir coroutine "Completing" veya "Completed" durumuna geçtiğinde, tekrar "Active" durumuna geri dönemez. complete
    metodunun döndürdüğü değer true ise, job bu çağrı sonucunda tamamlanmıştır; aksi takdirde, job zaten tamamlanmış
    olduğundan sonuç false olur.
import kotlinx.coroutines.Job import kotlinx.coroutines.delay import kotlinx.coroutines.launch import kotlinx.coroutines.runBlocking // Fun main işlevi, runBlocking coroutine oluşturucu içinde çalışır // runBlocking, içindeki tüm coroutine'lerin tamamlanmasını bekler fun main(): Unit = runBlocking { // Bağımsız bir Job oluşturuluyor // Job() fonksiyonu yeni bir CompletableJob nesnesi oluşturur val job = Job() // job ile ilişkilendirilmiş bir coroutine başlatılıyor // Bu coroutine'in yaşam döngüsü job'a bağlıdır launch(job) { // 5 kez tekrar edecek bir döngü başlatılıyor repeat(5) { num -> // Her yineleme arasında 200 milisaniye bekleniyor delay(200) // Mevcut yineleme numarası yazdırılıyor println("Tekrar$num") } } // Bağımsız bir coroutine başlatılıyor // Bu coroutine hiçbir job'a bağlı değildir launch { // 500 milisaniye bekleniyor delay(500) // job tamamlanıyor // complete() metodu job'ı başarıyla tamamlar job.complete() } // job tamamlanana kadar bekleniyor // join() metodu, job tamamlanana kadar mevcut coroutine'i askıya alır job.join() // job tamamlandığı için bu coroutine çalışmayacak // Tamamlanmış job'a yeni coroutine'ler bağlanamaz launch(job) { println("Bu satır yazdırılmayacak") } // Programın tamamlandığı belirtiliyor println("Tamamlandı") } // Çıktı: // Tekrar0 // Tekrar1 // Tekrar2 // Tekrar3 // Tekrar4 // Tamamlandı
v
  • completeExceptionally(exception: Throwable): Boolean - Bu metot, job'u belirtilen bir istisna (exception) ile
    tamamlar. Bu durumda, tüm alt job'lar hemen iptal edilir ve sağlanan istisna, bir CancellationException içine
    sarılarak iletilir. Eğer bu çağrı sonucunda job tamamlanmışsa, metot true döndürür; aksi takdirde, job zaten
    tamamlanmış olduğundan false döner.
import kotlinx.coroutines.Job import kotlinx.coroutines.delay import kotlinx.coroutines.launch import kotlinx.coroutines.runBlocking import java.lang.Error // Fun main işlevi, runBlocking coroutine oluşturucu içinde çalışır // runBlocking, içindeki tüm coroutine'lerin tamamlanmasını bekler //sampleStart fun main(): Unit = runBlocking { // Bağımsız bir Job oluşturuluyor // Job() fonksiyonu yeni bir CompletableJob nesnesi oluşturur val job = Job() // job ile ilişkilendirilmiş bir coroutine başlatılıyor // Bu coroutine'in yaşam döngüsü job'a bağlıdır launch(job) { // 5 kez tekrar edecek bir döngü başlatılıyor repeat(5) { num -> // Her yineleme arasında 200 milisaniye bekleniyor delay(200) // Mevcut yineleme numarası yazdırılıyor println("Tekrar$num") } } // Bağımsız bir coroutine başlatılıyor // Bu coroutine hiçbir job'a bağlı değildir launch { // 500 milisaniye bekleniyor delay(500) // job tamamlanıyor // complete() metodu job'ı başarıyla tamamlar job.complete() } // job tamamlanana kadar bekleniyor // join() metodu, job tamamlanana kadar mevcut coroutine'i askıya alır job.join() // job tamamlandığı için bu coroutine çalışmayacak // Tamamlanmış job'a yeni coroutine'ler bağlanamaz launch(job) { println("Bu satır yazdırılmayacak") } // Programın tamamlandığı belirtiliyor println("Tamamlandı") } // Çıktı: // Tekrar0 // Tekrar1 // Tekrar2 // Tekrar3 // Tekrar4 // Tamamlandı //sampleEnd
complete fonksiyonu, bir job üzerinde çalışan son coroutine başlatıldıktan sonra kullanılabilir.
Bu sayede, job'un tamamlanmasını beklemek için yalnızca join fonksiyonunu kullanabiliriz.
import kotlinx.coroutines.* // Suspend main fonksiyonu, coroutineScope oluşturucu içinde çalışır // coroutineScope, içindeki tüm coroutine'lerin tamamlanmasını bekler //sampleStart suspend fun main(): Unit = coroutineScope { // Bağımsız bir Job oluşturuluyor // Job() fonksiyonu yeni bir CompletableJob nesnesi oluşturur val job = Job() // job ile ilişkilendirilmiş bir coroutine başlatılıyor // yeni job, üst coroutine'den gelen job'un yerine geçiyor launch(job) { delay(1000) println("Metin 1") } // job ile ilişkilendirilmiş başka bir coroutine başlatılıyor // yeni job, üst coroutine'den gelen job'un yerine geçiyor launch(job) { delay(2000) println("Metin 2") } // Job tamamlanıyor // complete() metodu job'ı başarıyla tamamlar // Ancak bu, job'a bağlı coroutine'leri iptal etmez, // sadece yeni coroutine'lerin başlatılmasını engeller job.complete() // Job'un tamamlanmasını bekliyoruz // join() metodu, job'a bağlı tüm coroutine'ler // tamamlanana kadar bekler job.join() } // Çıktı: // Metin 1 (1 saniye sonra görünür) // Metin 2 (2 saniye sonra görünür) //sampleEnd
Job fonksiyonuna üst job'un (parent) bir referansını argüman olarak geçirebilirsiniz.
Bu sayede, üst job iptal edildiğinde, bu job da otomatik olarak iptal edilir.
import kotlinx.coroutines.* // Suspend main fonksiyonu, coroutineScope oluşturucu içinde çalışır // coroutineScope, içindeki tüm coroutine'lerin tamamlanmasını bekler suspend fun main(): Unit = coroutineScope { // Üst job oluşturuluyor // Bağımsız bir Job oluşturuluyor val parentJob = Job() // Üst job ile ilişkilendirilmiş bir job oluşturuluyor // Job(parentJob) fonksiyonu, parentJob'a bağlı yeni bir CompletableJob nesnesi oluşturur // parentJob iptal edilirse bu job da otomatik olarak iptal edilir val job = Job(parentJob) // job ile ilişkilendirilmiş coroutine başlatılıyor // Bu coroutine job'a bağlıdır, job iptal edilirse bu coroutine de iptal edilir launch(job) { delay(1000) println("Metin 1") } // job ile ilişkilendirilmiş ikinci coroutine başlatılıyor // Bu coroutine de job'a bağlıdır launch(job) { delay(2000) println("Metin 2") } // 1.1 saniye bekleniyor // Bu süre içinde ilk coroutine çalışır ve "Metin 1" yazdırılır delay(1100) // Üst job iptal ediliyor, alt job'lar da iptal edilecek // parentJob'ın iptal edilmesi job'ın da iptal edilmesine neden olur // job'ın iptal edilmesi de ona bağlı tüm coroutine'lerin iptal edilmesine neden olur parentJob.cancel() // Alt job'ların tamamlanması bekleniyor // job.children, job'a bağlı tüm coroutine'lerin job nesnelerini içerir // forEach döngüsü her bir alt job için join() çağırır ve tamamlanmalarını bekler job.children.forEach { it.join() } } // Çıktı:

Coroutineleri Senkronize Etme

Coroutineleri senkronize etmek için Job nesnesinin join fonksiyonunu kullanmak yaygın bir yöntemdir. Örneğin, bir
işlemin başka bir coroutine tamamlandıktan sonra başlamasını sağlamak istiyorsanız, ilk coroutine'in job bileşeninde
join fonksiyonunu kullanabilirsiniz.
/** * SomeService sınıfı, coroutine'leri kullanarak asenkron görevleri yöneten bir servistir. * @param scope Coroutine'lerin çalıştırılacağı kapsam. Bu, servisin dışından enjekte edilir * böylece coroutine'lerin yaşam döngüsü daha iyi kontrol edilebilir. */ class SomeService( private val scope: CoroutineScope ) { /** * Asenkron görevleri başlatır ve yürütülmelerini koordine eder. * Bu metod, birbirleriyle iletişim kurabilen iki coroutine başlatır. */ fun startTasks() { // İlk coroutine'i başlatır ve referansını bir job olarak saklar // Bu, diğer coroutine'lerin bu görevin tamamlanmasını beklemesine olanak tanır val job = scope.launch { // İlk asenkron görevin kodu buraya gelir // ... } // İlk göreve bağımlı olan ikinci bir coroutine başlatır scope.launch { // İkinci görevin başlangıç kodu // ... // job.join() çağrısı, ilk görev tamamlanana kadar bu coroutine'i askıya alır // Bu, thread'leri bloke etmeden iki görev arasında bir bağımlılık oluşturur job.join() // İlk görev tamamlandıktan sonra çalıştırılacak kod // ... } } }
Benzer şekilde, bir dizi job'u bir araya getirerek hepsinin tamamlanmasını bekleyebiliriz. Aynı işlem async ve await
kullanılarak da gerçekleştirilebilir. await fonksiyonunun döndürdüğü değer Deferred türündedir ve bu tür,Job
arayüzünün bir alt türü olduğu için join fonksiyonunu da kullanabiliriz. Ancak, await fonksiyonu coroutine'in
sonucunu da döndürdüğü için genellikle join yerine tercih edilir.
Coroutineleri senkronize etmek için oldukça kullanışlı olan CompletableDeferred sınıfı, tamamlanabilir bir değer (
deferred value) içeren ve bir tamamlama fonksiyonuna sahip bir yapıdır. Bir değerin (complete) veya bir istisnanın (
completeExceptionally) atanarak tamamlanmasını sağlar. Ayrıca, bir coroutine await fonksiyonunu kullanarak
CompletableDeferred nesnesinin tamamlanmasını bekleyebilir.
import kotlinx.coroutines.* /** * Bu örnek, Kotlin'deki CompletableDeferred kullanımını göstermektedir. * CompletableDeferred, asenkron işlemler arasında veri paylaşımı için kullanılan * bir mekanizmadır. */ fun main(): Unit = runBlocking { // Tamamlanabilir bir deferred nesnesi oluşturuluyor // CompletableDeferred<T>, gelecekte bir değer üretecek olan ve programatik olarak // tamamlanabilen bir asenkron işlemi temsil eder val deferred = CompletableDeferred<String>() // İlk coroutine'i başlatıyoruz launch { println("İlk işlem başlatılıyor") delay(1000) // 1 saniye bekleniyor - asenkron bekleme, thread bloke edilmez // deferred nesnesi "Test" değeriyle tamamlanıyor // Bu, await() çağrısı yapan tüm coroutine'lerin devam etmesini sağlar deferred.complete("Test") delay(1000) // 1 saniye daha bekleniyor println("İlk işlem tamamlandı") } // İkinci coroutine'i başlatıyoruz - bu, paralel olarak çalışacak launch { println("İkinci işlem başlatılıyor") // deferred tamamlanana kadar bekleniyor // await() fonksiyonu, deferred nesnesinin değeri hazır olana kadar // bu coroutine'i askıya alır - thread bloke edilmez println(deferred.await()) println("İkinci işlem tamamlandı") } } // Çıktı: // İlk işlem başlatılıyor / İkinci işlem başlatılıyor (iki işlem de hemen başlar) // (1 saniye) // Test (deferred.complete() çağrıldıktan sonra await() değer döndürür) // İkinci işlem tamamlandı (await() tamamlandıktan hemen sonra) // (1 saniye) // İlk işlem tamamlandı (ilk coroutine'deki ikinci delay'den sonra)
CompletableDeferred, bazı coroutinelerin, başka bir coroutine tarafından üretilen bir değeri veya olayı beklemesi
gerektiğinde faydalıdır. CompletableDeferred, yalnızca tek bir değer kabul eder ve bu değer, birden fazla coroutine
tarafından birden çok kez beklenebilir (await). Eğer birden fazla değeri işlemek istiyorsanız, bunun yerine
Channel
kullanmalısınız. Channel, özel olarak ayrılmış bir bölümde ayrıntılı olarak ele alınacaktır.

Özet

Bu bölümde şunları öğrendik:
  • Job, her coroutine için en önemli bağlamdır. İptal edilebilir ve bir yaşam döngüsüne sahiptir. Ayrıca bir durumu
    vardır ve coroutineleri iptal etmek, durumlarını izlemek ve daha fazlası için kullanılabilir.
  • Her coroutine kendi job bileşenine sahiptir ve bu, üst coroutine'den miras alınmayan tek bağlamdır. Bir argümandan
    veya üst coroutine'den alınan job, yeni job için üst job olarak kullanılır.
  • Coroutineler şu durumlardan birinde olabilir: "New", "Active", "Completing", "Completed", "Cancelling" ve "
    Cancelled". Normal coroutineler "Active" durumunda başlar; gövdeleri tamamlandığında "Completing" durumuna geçerler;
    çocuk coroutineler tamamlandıktan sonra ise "Completed" durumuna geçerler.
  • Job() fonksiyonunu doğrudan bir coroutine'in üst job'u olarak kullanmaktan kaçınılmalıdır, çünkü bu beklenmeyen
    davranışlara yol açabilir
  • Job, coroutineleri senkronize etmek için kullanılabilir. Bir coroutine'in tamamlanmasını beklemek için join
    fonksiyonunu kullanabiliriz veya başka bir coroutine tarafından üretilen bir değeri beklemek için
    CompletableDeferred kullanabiliriz.
Sonraki iki bölüm, Kotlin Coroutines'te iptal mekanizmasını ve istisna yönetimini ele alacaktır. Bu iki önemli
mekanizma,
Job kullanılarak oluşturulan üst-alt coroutine ilişkisine dayanır.
  1. 1.Evet, kendimi tekrar ediyorum, ancak hatırlamanızı en çok istediğim şey Job'un miras alınmadığıdır. ↩
  2. 2.toString metodunun hata ayıklama ve günlük kaydı (logging) amaçları için kullanılması gerektiğini tekrar hatırlatmama gerek olmadığını umuyorum. Kod içinde ayrıştırılması bu metodun sözleşmesini ihlal eder ve Effective Kotlin kitabında açıkladığım gibi hatalara yol açar. ↩
  3. 3.Effective Kotlin kitabında Madde 32: Yapıcılar yerine fabrika fonksiyonlarını değerlendirin bölümünde ↩