
Bu metin, Kotlin Coroutines kitabının bir bölümüdür. Kitabın tamamına LeanPub üzerinden erişebilirsiniz
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.
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 arayüzünü (interface) uygulayan bir bağlamdır ve Job anahtarı (key) ile tanımlanır. İptal edilebilirve 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 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 }
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 }
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 Jobbileşenini oluşturur ve bir argümandan veya üst coroutine'den gelen
Job, bu yeni Job bileşeninin ebeveyni olarakatanır1Evet, kendimi tekrar ediyorum, ancak hatırlamanızı en çok istediğim şey
Job'un miras alınmadığıdır..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 } }
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 örnekteolduğu gibi,
runBlocking, launch coroutine'inin üst coroutine'idir çünkü launch, runBlocking tarafından sağlanankapsam 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 }
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 }
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 coroutinekendi (bağımsız)
Job bileşenine sahipse, üst coroutine ile neredeyse hiçbir ilişkisi kalmaz. Diğer bağlamları mirasalı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.
(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.
"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.
toString metodunda gösterilir2toString 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.. Aşağıdaki örnekte, farklı job'ların durum değişimlerinigö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 }
isActive, isCompleted ve isCancelled özelliklerini kullanırız.| Durum | isActive | isCompleted | isCancelled |
|---|---|---|---|
| New (isteğe bağlı başlangıç durumu) | false | false | false |
| Active (varsayılan başlangıç durumu) | true | false | false |
| Completing (geçici durum) | true | false | false |
| Cancelling (geçici durum) | false | false | true |
| Cancelled (son durum) | false | true | true |
| Completed (son durum) | false | true | false |
Job arayüzü, job ile etkileşime geçmek için kullanabileceğimiz bazı yararlı fonksiyonlar sunar. Bunlardan biri olanjoin, bir job'un tamamlanmasını beklemek için kullanılır.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
join metodunun kullanılması yaygın bir durumdur. Aşağıdaki örneği elealalı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.
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 dakullanabilirsiniz. Tek fark,
await coroutine'in sonucunu döndürürken, join metodunun Unit döndürmesidir.Job() fabrika fonksiyonunu kullanarak bir Job oluşturulabilir. Job() fonksiyonu, herhangibir 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.
Job() fabrika fonksiyonunu kullanarak bir job oluşturmak, ardından bunu bazı coroutine'ler için üstjob olarak kullanmak ve son olarak bu job üzerinde
join metodunu çağırmaktır. Böyle bir program asla sonaermeyecektir, çünkü
Job bileşeni, tüm alt coroutine'ler tamamlanmış olsa bile hâlâ "Active" durumundadır. Bununnedeni, 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
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 örnektir3Effective Kotlin kitabında Madde 32: Yapıcılar yerine fabrika fonksiyonlarını değerlendirin bölümünde. İ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 birJob 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ğertrueise, job bu çağrı sonucunda tamamlanmıştır; aksi takdirde, job zaten tamamlanmış
olduğundan sonuçfalseolur.
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ı
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, birCancellationExceptioniçine
sarılarak iletilir. Eğer bu çağrı sonucunda job tamamlanmışsa, metottruedöndürür; aksi takdirde, job zaten
tamamlanmış olduğundanfalsedö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ı:
Job nesnesinin join fonksiyonunu kullanmak yaygın bir yöntemdir. Örneğin, biriş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 // ... } } }
async ve awaitkullanılarak da gerçekleştirilebilir.
await fonksiyonunun döndürdüğü değer Deferred türündedir ve bu tür,Jobarayüzünün bir alt türü olduğu için
join fonksiyonunu da kullanabiliriz. Ancak, await fonksiyonu coroutine'insonucunu da döndürdüğü için genellikle
join yerine tercih edilir.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 kullanarakCompletableDeferred 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ı beklemesigerektiğinde faydalıdır.
CompletableDeferred, yalnızca tek bir değer kabul eder ve bu değer, birden fazla coroutinetarafından birden çok kez beklenebilir (
await). Eğer birden fazla değeri işlemek istiyorsanız, bunun yerineChannelkullanmalısınız.
Channel, özel olarak ayrılmış bir bölümde ayrıntılı olarak ele alınacaktır.-
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çinjoin
fonksiyonunu kullanabiliriz veya başka bir coroutine tarafından üretilen bir değeri beklemek için
CompletableDeferredkullanabiliriz.
mekanizma,
Job kullanılarak oluşturulan üst-alt coroutine ilişkisine dayanır.- 1.Evet, kendimi tekrar ediyorum, ancak hatırlamanızı en çok istediğim şey
Job'un miras alınmadığıdır. ↩ - 2.
toStringmetodunun 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.Effective Kotlin kitabında Madde 32: Yapıcılar yerine fabrika fonksiyonlarını değerlendirin bölümünde ↩