İş Parçacığı Yöneticileri (Dispatchers)

İş Parçacığı Yöneticileri (Dispatchers)

Bu metin, Kotlin Coroutines kitabının bir bölümüdür. Kitabın tamamına LeanPub üzerinden erişebilirsiniz
Kotlin'in eşzamanlı işlem kütüphanesi, bir eşzamanlı işlemin (coroutine) hangi iş parçacığında (thread) veya iş
parçacığı havuzunda çalışacağını belirleme yeteneği sunar. Bu, iş parçacığı yöneticileri (dispatchers) kullanılarak
gerçekleştirilir.
İngilizce sözlükte dispatcher kelimesi, "özellikle acil durum araçları olmak üzere, insanları veya araçları ihtiyaç
duyulan yerlere göndermekten sorumlu kişi(hareket veya sevk memuru)" olarak tanımlanır. Kotlin’de ise
CoroutineContext, belirli bir eşzamanlı
işlemin hangi iş parçacığında çalışacağını belirler.
Kotlin Coroutines'teki iş parçacığı yöneticileri (dispatchers), RxJava'daki zamanlayıcılar (schedulers) ile benzer bir
kavrama sahiptir.

Varsayılan Coroutine Yöneticisi (Default Dispatcher)

Eğer bir eşzamanlı işlem için özel bir iş parçacığı yöneticisi belirtmezseniz, varsayılan olarak Dispatchers.Default
atanır. Dispatchers.Default, işlemci yoğunluklu (CPU-intensive) görevleri çalıştırmak için tasarlanmıştır.
Bu yöneticinin iş parçacığı havuzu, kodun çalıştığı makinedeki işlemci çekirdeklerinin sayısına eşit olacak şekilde
oluşturulur (ancak en az iki iş parçacığı olacak şekilde ayarlanmıştır). Teorik olarak, iş parçacıklarını verimli
kullanmanız (örneğin, işlemci yoğunluklu hesaplamalar yapıp iş parçacıklarını engellemeden çalıştırmanız) durumunda, bu
en uygun iş parçacığı sayısıdır.
Bu iş parçacığı yöneticisinin nasıl çalıştığını görmek için aşağıdaki kodu çalıştırabilirsiniz:
import kotlinx.coroutines.coroutineScope import kotlinx.coroutines.launch import kotlin.random.Random // Örnek Başlangıcı suspend fun main(): Unit = coroutineScope { repeat(1000) { launch { // veya launch(Dispatchers.Default) olarak da belirtilebilir // İşlemciyi yoğun şekilde çalıştırmak için rastgele uzun tamsayılar üreten bir liste oluşturur List(1_000_000) { Random.nextLong() }.maxOrNull() // Mevcut iş parçacığının adını alır val threadName = Thread.currentThread().name println("Çalışan iş parçacığı: $threadName") } } } // Örnek Sonu
Benim makinemdeki örnek çıktı (12 çekirdekli bir işlemcim var, bu yüzden havuzda 12 iş parçacığı bulunuyor):
Çalışan iş parçacığı: DefaultDispatcher-worker-1
Çalışan iş parçacığı: DefaultDispatcher-worker-5
Çalışan iş parçacığı: DefaultDispatcher-worker-7
Çalışan iş parçacığı: DefaultDispatcher-worker-6
Çalışan iş parçacığı: DefaultDispatcher-worker-11
Çalışan iş parçacığı: DefaultDispatcher-worker-2
Çalışan iş parçacığı: DefaultDispatcher-worker-10
Çalışan iş parçacığı: DefaultDispatcher-worker-4
...
...
Uyarı: runBlocking, herhangi bir dağıtıcı (dispatcher) belirtilmediğinde kendi varsayılan dağıtıcısını kullanır.
Bu nedenle, runBlocking kapsamı içinde çalıştırılan işlemler otomatik olarak Dispatchers.Default kullanmaz.
Eğer yukarıdaki örnekte coroutineScope yerine runBlocking kullansaydık,
tüm işlemler "main" iş parçacığında çalışacaktı.

Varsayılan Dağıtıcıyı (Dispatcher) Sınırlama

Diyelim ki yüksek işlem gücü gerektiren bir süreciniz var ve bu sürecin Dispatchers.Default tarafından kullanılan tüm
iş parçacıklarını (threads) tüketerek aynı dağıtıcıyı kullanan diğer eşzamanlı işlemleri engelleyebileceğinden
şüpheleniyorsunuz.
Böyle bir senaryoda, Dispatchers.Default üzerinde limitedParallelism fonksiyonunu kullanarak bir sınırlandırma
getirebiliriz. Bu fonksiyon, aynı iş parçacığı havuzunu kullanmaya devam ederken, aynı anda çalışabilecek iş parçacığı
sayısını belirli bir maksimum değere sınırlar. Böylece, yoğun işlem gerektiren görevlerin tüm kaynakları tüketmesi
önlenerek sistemde daha dengeli bir iş yükü dağılımı sağlanır.
Bu yöntem, özellikle birden fazla eşzamanlı işlemin yürütüldüğü sistemlerde kaynak yönetimini optimize etmek ve iş
parçacıklarının verimli bir şekilde tahsis edilmesini sağlamak için önemlidir.
// Bu satır, Dispatchers.Default dispatcher'ını kullanarak belirli bir eşzamanlılık (concurrency) sınırı tanımlar. private val dispatcher = Dispatchers.Default .limitedParallelism(5)
Eğer daha önce limitedParallelism fonksiyonunu gördüyseniz, Dispatchers.Default ile Dispatchers.IO üzerinde
tamamen farklı bir davranış sergilediğini bilmelisiniz. Bu farkları ilerleyen bölümlerde detaylı olarak ele alacağız.
limitedParallelism, kotlinx-coroutines kütüphanesinin 1.6 sürümüyle birlikte tanıtılmıştır. Bu nedenle, eski
projelerde bu fonksiyonun kullanımına rastlamayabilirsiniz.

Ana Dağıtıcı (Main Dispatcher)

Android ve birçok uygulama çerçevesi, genellikle kullanıcı arayüzü (UI) ile etkileşime giren tek iş parçacığı olan bir
ana iş parçacığı(Main Thread) kavramına sahiptir. Android’de bu iş parçacığı özellikle önemlidir çünkü UI
güncellemeleri yalnızca bu iş parçacığı üzerinden gerçekleştirilebilir.Bu nedenle, çok sık kullanılması gerekir fakat bu
büyük bir özenle yapılmalıdır.. Ana iş parçacığı engellenirse (örneğin uzun süren bir işlem çalıştırılırsa), tüm
uygulama donarak tepki vermez hale gelir.Android’de Ana İş Parçacığı üzerinde bir eşzamanlı işlem başlatmak için
Dispatchers.Main kullanılır.
// 'suspend' anahtar kelimesi, bu fonksiyonun askıya alınabilir olduğunu belirtir. Yani, bu fonksiyon // başka askıya alınabilir fonksiyonlar içinde çağrılabilir ve bekleyebilir. suspend fun showUserName(name: String) = // withContext, çalışma bağlamını (dispatcher) değiştirir. Bu örnekte, UI işlemlerini ana iş parçacığında // (Main thread) yapabilmek için Dispatchers.Main kullanılır. withContext(Dispatchers.Main) { // userNameTextView'in metin değerini, fonksiyona geçirilen 'name' parametresiyle günceller. userNameTextView.text = name }
Dispatchers.Main, Android platformunda kullanılabilmesi için kotlinx-coroutines-android bağımlılığı eklenerek
etkinleştirilebilir. Benzer şekilde, JavaFX için kotlinx-coroutines-javafx, Swing için ise kotlinx-coroutines-swing
bağımlılıkları eklenmelidir. Eğer bir proje, ana iş parçacığını belirleyen bir bağımlılığa sahip değilse,
Dispatchers.Main kullanılamaz. Özellikle, ön yüz (frontend) kütüphaneleri birim testlerinde (unit tests) genellikle
kullanılmaz. Bu nedenle, test ortamında Dispatchers.Main varsayılan olarak tanımlı değildir. Birim testlerinde
Dispatchers.Main kullanabilmek için kotlinx-coroutines-test kütüphanesinde yer alan
Dispatchers.setMain(dispatcher) fonksiyonu ile özel bir dağıtıcı (dispatcher) atanmalıdır.
class SomeTest { // Tek iş parçacıklı bir yürütücü (executor) oluşturulur ve // bu yürütücü bir coroutine dağıtıcısına (dispatcher) dönüştürülür. private val dispatcher = Executors .newSingleThreadExecutor() .asCoroutineDispatcher() @Before fun setup() { // Testler başlamadan önce, ana iş parçacığını (Main dispatcher) // tek iş parçacıklı özel dağıtıcıya yönlendirir. Dispatchers.setMain(dispatcher) } @After fun tearDown() { // Testler tamamlandıktan sonra, ana dağıtıcı orijinal // haline döndürülür. Dispatchers.resetMain() dispatcher.close() // Oluşturulan yürütücü kapatılır. } @Test fun testSomeUI() = runBlocking { launch(Dispatchers.Main) { // Burada ana iş parçacığı üzerinde çalışacak // test edilecek UI kodları yer alır. } } }
Android'de genellikle Dispatchers.Main varsayılan olarak kullanılır. Eğer kullandığınız kütüphaneler iş parçacıklarını
engellemek yerine askıya alıyorsa (suspending functions) ve herhangi bir karmaşık hesaplama yapmıyorsanız, pratikte
yalnızca Dispatchers.Main kullanmanız yeterli olabilir. Ancak, eğer CPU yoğun (CPU-intensive) işlemler yapıyorsanız,
bunları Dispatchers.Default üzerinde çalıştırmanız gereklidir. Çoğu uygulama için Dispatchers.Main ve
Dispatchers.Default yeterli olur.
Ancak, bazı durumlarda bir iş parçacığını engellemeniz (blocking operations) gerekebilir. Örneğin:
  • Büyük dosyaların okunması veya yazılması gibi uzun süren G/Ç (I/O) işlemleri.
  • Engelleyici (blocking) fonksiyonlar içeren bir kütüphanenin kullanılması.
Bu tür işlemleri ana iş parçacığında (Main thread) çalıştırmak, uygulamanın donmasına neden olur.
Varsayılan dağıtıcıyı (Dispatchers.Default) engellemek, tüm iş parçacıklarının kilitlenmesine neden olabilir.
Bu durumda, hesaplama yapmak için iş parçacığı bulunamayacağı için uygulama yanıt vermez hale gelir. Bu nedenle, bu tür
engelleyici işlemleri yönetmek için Dispatchers.IO kullanılmalıdır. Dispatchers.IO, büyük
G/Ç işlemlerini daha verimli bir şekilde yürütmek için tasarlanmış bir iş parçacığı havuzu sağlar.

Giriş/Çıkıș (GÇ/IO ) Dağıtıcısı

Dispatchers.IO, iş parçacıklarını engelleyen (blocking) G/Ç (I/O) işlemleri için tasarlanmıştır. Örneğin, dosya
okuma/yazma işlemleri veya engelleyici (blocking) fonksiyon çağrıları gibi işlemler için kullanılır.
Aşağıdaki kodun yürütülmesi yaklaşık 1 saniye sürer çünkü Dispatchers.IO aynı anda 50'den fazla aktif iş parçacığının
çalışmasına izin verir. Bu, büyük ölçekli G/Ç işlemlerinin verimli bir şekilde yönetilmesini sağlar.
import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.coroutineScope import kotlinx.coroutines.launch import kotlin.system.measureTimeMillis // Bu program Kotlin Coroutines ile IO işlemlerinin paralelleştirilmesini göstermektedir suspend fun main() { // measureTimeMillis fonksiyonu, içindeki kod bloğunun çalışma süresini milisaniye cinsinden ölçer val time = measureTimeMillis { // coroutineScope, tüm alt coroutine'lerin tamamlanmasını bekleyen bir kapsamdır coroutineScope { // repeat(50), aynı bloğu 50 kez tekrarlar repeat(50) { // launch, yeni bir coroutine başlatır // Dispatchers.IO, bloke edici işlemler için optimize edilmiş bir thread havuzu kullanır launch(Dispatchers.IO) { // Thread.sleep(1000), mevcut thread'i 1 saniye boyunca bloke eder Thread.sleep(1000) } } } } // Ölçülen süreyi ekrana yazdırır, yaklaşık 1000 milisaniye (1 saniye) olması beklenir println(time) // ~1000 }
Dispatchers.IO yalnızca iş parçacıklarını engelleyen (blocking) API'lere ihtiyacınız olduğunda gereklidir.
Eğer askıya alınabilir (suspending) fonksiyonlar kullanıyorsanız, herhangi bir dağıtıcıyı (dispatcher)
kullanabilirsiniz. Ağ veya veritabanı işlemleri gibi askıya alınabilir fonksiyonlar sunan bir kütüphane
kullanıyorsanız, Dispatchers.IO kullanmanıza gerek yoktur. Bu nedenle, birçok projede Dispatchers.IO
kullanımı tamamen gereksiz olabilir.
Dispatchers.IO, teorik olarak sınırsız bir iş parçacığı havuzu (thread pool) gibi çalışır.
Başlangıçta boş olan bu havuz, ihtiyaç duyuldukça yeni iş parçacıkları oluşturur ve belirli bir süre kullanılmazlarsa
devre dışı bırakır. Ancak, bu tür sınırsız bir iş parçacığı yönetimi doğrudan kullanıldığında güvenli değildir.
Çok fazla aktif iş parçacığı oluşturmak, performansın yavaş ve kontrolsüz bir şekilde düşmesine neden olur ve en sonunda
bellek tükenmesi (out-of-memory error) gibi hatalara yol açabilir.
Bu yüzden Kotlin Coroutines kütüphanesindeki tüm temel dağıtıcılar, aynı anda kullanabilecekleri iş parçacığı
sayısını sınırlandırır:
  • Dispatchers.Default: İşlemcinizin çekirdek sayısı ile sınırlıdır.
  • Dispatchers.IO: Aynı anda en fazla 64 iş parçacığına izin verir (Eğer sistemde 64'ten fazla çekirdek varsa,
    çekirdek sayısı kadar olabilir).
import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.coroutineScope import kotlinx.coroutines.launch // Örnek Başlangıcı suspend fun main(): Unit = coroutineScope { // 1000 adet eşzamanlı işlem başlatılır repeat(1000) { // IO işlemleri için özel dağıtıcı kullanılır launch(Dispatchers.IO) { // İş parçacığını 200 milisaniye boyunca bloke eder Thread.sleep(200) // Mevcut iş parçacığının adını alır val threadName = Thread.currentThread().name // Hangi iş parçacığında çalıştığını yazdırır println("Running on thread: $threadName") } } } // Örnek Çıktısı (Farklı çalıştırmalarda iş parçacıklarının numarası değişebilir): // Running on thread: DefaultDispatcher-worker-1 //... // Running on thread: DefaultDispatcher-worker-53 // Running on thread: DefaultDispatcher-worker-14 // Örnek Sonu
Daha önce belirttiğimiz gibi, Dispatchers.Default ve Dispatchers.IO aynı iş parçacığı havuzunu paylaşmaktadır.
Bu durum, önemli bir optimizasyon sağlar. İş parçacıkları yeniden kullanılır ve çoğu zaman yeniden dağıtım (
redispatching) gerekmez. Örneğin, Dispatchers.Default üzerinde çalışan bir işlem (coroutine),
withContext(Dispatchers.IO) { ... } bloğuna ulaştığında, genellikle aynı iş parçacığında çalışmaya devam eder1.
Ancak burada değişen şey, iş parçacığınınDispatchers.Default sınırı yerine Dispatchers.IO sınırına dahil olmasıdır.
Bu iki dağıtıcının sınırları bağımsızdır, yani biri diğerini engelleyemez (starvation durumu oluşmaz).
Böylece CPU yoğun işlemler (Dispatchers.Default) ve bloklayan IO işlemleri (Dispatchers.IO) birbirlerini
engellemeden verimli bir şekilde çalıştırılabilir.
import kotlinx.coroutines.* // Bu bir main fonksiyon ama suspend olarak tanımlanmış, yani coroutine içinde çalışabilir suspend fun main(): Unit = coroutineScope { // Yeni bir coroutine başlatılıyor ve Dispatchers.Default üzerinde çalışacak şekilde ayarlanıyor // Dispatchers.Default, CPU yoğun işlemler için optimize edilmiş bir dispatcher launch(Dispatchers.Default) { // Şu anda çalışan thread'in adını yazdırıyor println(Thread.currentThread().name) // withContext ile çalışma bağlamı Dispatchers.IO'ya değiştiriliyor // Dispatchers.IO, I/O işlemleri için tasarlanmış, daha fazla eşzamanlılık sağlayan bir dispatcher withContext(Dispatchers.IO) { // IO dispatcher bağlamına geçilmiş olmasına rağmen, hala aynı thread üzerinde çalışıyor mu kontrol ediliyor println(Thread.currentThread().name) } } } // Çıktı: // DefaultDispatcher-worker-2 <- Default dispatcher üzerinde çalışırken kullanılan thread adı // DefaultDispatcher-worker-2 <- IO dispatcher'a geçildiğinde hala aynı thread kullanılıyor
Bu durumu daha net görmek için, hem Dispatchers.Default hem de Dispatchers.IO kullanılarak maksimum iş parçacığı (
thread) kapasitesine ulaşıldığını hayal edin. Bu durumda, aktif iş parçacıklarının sayısı her iki dağıtıcının (
dispatcher) sınırlarının toplamı kadar olacaktır. Örneğin, Dispatchers.IO için 64 iş parçacığına izin verildiğini ve
sisteminizde 8 çekirdek bulunduğunu varsayarsak, paylaşılan havuzda toplam 72 aktif iş parçacığı olur. Bu, iş
parçacıklarının verimli şekilde yeniden kullanılmasını sağlarken, aynı zamanda iki dağıtıcının birbirinden bağımsız
şekilde çalışmasına olanak tanır.
Dispatchers.IO kullanımının en yaygın olduğu senaryo, harici kütüphanelerden gelen bloklayan fonksiyonları (
blocking functions) çağırma ihtiyacıdır. En iyi uygulama (best practice), bu tür fonksiyonları
withContext(Dispatchers.IO) bloğu içinde sarmalamaktır.
// DiscUserRepository sınıfı, UserRepository arayüzünü (interface) uygulayarak // kullanıcı verilerini diskten okuma işlemini gerçekleştirir class DiscUserRepository( // DiscReader, dosya sisteminden veri okuyabilen bir bağımlılık // Constructor enjeksiyonu ile dışarıdan sağlanıyor private val discReader: DiscReader ) : UserRepository { // UserRepository arayüzünden gelen getUser metodunu uygulama // suspend fonksiyon olarak tanımlanmış, yani coroutine içinde çağrılabilir override suspend fun getUser(): UserData = // IO dispatcher kullanılıyor çünkü disk okuma işlemi bir I/O operasyonudur withContext(Dispatchers.IO) { // Diskten "userName" değerini okuyor ve bu değerle yeni bir UserData nesnesi oluşturuyor UserData(discReader.read("userName")) } }
Dispatchers.IO için bir sınırın neden gerekli olduğunu daha iyi anlamak için, belirli aralıklarla çalışan ve çok
sayıda eşzamanlı işlem başlatan bir görev (task) hayal edin. Örneğin, bir bloklayan API (blocking API) kullanarak
toplu e-posta gönderimi yapmanız gerektiğini düşünelim.Bu işlem için SendGrid gibi harici bir e-posta servis sağlayıcısı
kullanılabilir. Eğer Dispatchers.IO herhangi bir sınıra sahip olmasaydı, her e-posta için ayrı bir iş parçacığı (
thread) oluşturulurdu. Yani, 100.000 e-posta gönderimi yapmanız gerekiyorsa, sistem 100.000 iş parçacığı başlatmaya
çalışırdı. Bu da yaklaşık 100 GB RAM tüketimine neden olur ve uygulamanın çökmesine yol açardı. İşte bu nedenle,
Dispatchers.IO belirli bir sınır ile çalışır. Böylece, iş parçacıklarının kontrolsüz şekilde artmasının önüne geçilir
ve sistem kaynakları verimli bir şekilde kullanılır.
class NewsletterService { // SendGrid email servisi için bir API istemcisi oluşturuluyor // API_KEY değişkeni, SendGrid'e erişim için gereken kimlik anahtarını içeriyor private val sendGrid = SendGrid(API_KEY) // Bülten gönderme işlemini gerçekleştiren suspend fonksiyon suspend fun sendNewsletter( newsletter: Newsletter, // Gönderilecek bültenin içeriği emails: List<Email> // Bültenin gönderileceği email adresleri listesi ) = withContext(Dispatchers.IO) { // IO dispatcher kullanılıyor çünkü bu bir ağ işlemidir // Her email için ayrı bir coroutine başlatılıyor emails.forEach { email -> // Her email için paralel olarak yeni bir coroutine başlatılıyor launch { // SendGrid API'sini kullanarak email gönderiliyor // createNewsletter fonksiyonu, her alıcı için özelleştirilmiş bülten oluşturuyor sendGrid.api(createNewsletter(email, newsletter)) } } } // Diğer yardımcı fonksiyonlar burada yer alıyor (kodda gösterilmemiş) // ... }
Bu sınır, sistem kaynaklarını korur ancak işlemlerin daha uzun sürmesine neden olabilir. Örneğin, her bir e-posta
gönderiminin ortalama 100 milisaniye sürdüğünü ve toplamda 100.000 e-posta gönderilmesigerektiğini düşünelim.
Dispatchers.IO 64 iş parçacığı ile sınırlandırıldığında, tüm e-postaların gönderilmesiyaklaşık 3 dakika sürecektir.
Dispatchers.IO ile ilgili temel sorun, tüm uygulama genelinde tek bir sınıra sahip olmasıdır.Bu, bir servis (
service) yoğun bir şekilde Dispatchers.IO kullanırken, diğer servislerin iş parçacığına erişimini engelleyebilir.
Örneğin, aynı uygulama içerisinde hem toplu e-posta gönderimi yapan bir servis hem de kullanıcı kayıt işlemleri için
onay e-postaları gönderen bir servis olduğunu düşünelim. Eğer her iki servis de Dispatchers.IO kullanıyorsa, öncelikli
olarak toplu e-posta işlemi tamamlanana kadar kayıt onay e-postaları gönderilemeyecektir. Bu da kullanıcıların kayıt
işlemi sırasında uzun süre beklemesine neden olur. Bu tür durumların yaşanmaması için, bağımsız sınırlara sahip özel
dağıtıcılar (dispatchers) oluşturulmalıdır.

Özel Sınırlamalı Dağıtıcı

Dispatchers.IO, limitedParallelism fonksiyonuna özel bir davranış tanımlar. Bu fonksiyon, bağımsız bir iş parçacığı
sınırı belirleyerek yeni bir dağıtıcı (dispatcher) oluşturur. Örneğin, her biri bir saniyeliğine bir iş parçacığını
engelleyen 100 eşzamanlı işlem (coroutine) başlattığınızı düşünelim:
  • Eğer bu işlemleri doğrudan Dispatchers.IO üzerinde çalıştırırsanız, toplam işlem süresi 2 saniye sürebilir.
  • Eğer işlemleri Dispatchers.IO.limitedParallelism(100) üzerinde çalıştırırsanız,
    her biri aynı anda çalışabileceği için toplam işlem süresi sadece 1 saniye sürecektir.
Bu iki dağıtıcının (dispatcher) yürütme süreleri aynı anda ölçülebilir çünkü bu iki dağıtıcının sınırları birbirinden
bağımsızdır. Bu sayede, limitedParallelism kullanarak farklı görevler için belirli bir iş parçacığı sınırı belirlemek
mümkündür.Bu yöntem, kritik işlemlerin diğer işlemlerle çakışmasını önlemek için kullanışlıdır.
import kotlinx.coroutines.* import kotlin.system.measureTimeMillis // Ana fonksiyon, suspend olarak işaretlenmiş ve bir coroutineScope içinde çalışıyor suspend fun main(): Unit = coroutineScope { // İlk coroutine başlatılıyor launch { // Standard IO dispatcher ile ölçüm yapılıyor printCoroutinesTime(Dispatchers.IO) // Çıktı: "Dispatchers.IO took: 2074" - yaklaşık 2 saniye sürdü } // İkinci coroutine başlatılıyor launch { // Dispatchers.IO'dan özel, paralel işlem limiti 100 olan yeni bir dispatcher oluşturuluyor val dispatcher = Dispatchers.IO .limitedParallelism(100) printCoroutinesTime(dispatcher) // Çıktı: "LimitedDispatcher@XXX took: 1082" - yaklaşık 1 saniye sürdü } } // Belirli bir dispatcher ile 100 coroutine başlatıp bunların tamamlanma süresini ölçen fonksiyon suspend fun printCoroutinesTime( dispatcher: CoroutineDispatcher ) { // Bu bloğun ne kadar sürdüğünü ölçmek için measureTimeMillis kullanılıyor val test = measureTimeMillis { coroutineScope { // 100 kez tekrarlayan bir döngü repeat(100) { // Her tekrarda belirtilen dispatcher üzerinde yeni bir coroutine başlatılıyor launch(dispatcher) { // Her coroutine içinde 1 saniye bekletiliyor (bloklandığına dikkat edin) Thread.sleep(1000) } } } // coroutineScope, içindeki tüm coroutine'ler tamamlanana kadar bekler } // Toplam geçen süre ve hangi dispatcher'ın kullanıldığı yazdırılıyor println("$dispatcher took: $test") }
Kavramsal olarak, Dispatchers.Default ve Dispatchers.IO tarafından kullanılan sınırsız bir iş parçacığı havuzu
vardır, ancak her iki dağıtıcı da bu iş parçacıklarına sınırlı erişime sahiptir. Dispatchers.IO üzerinde
limitedParallelism kullandığımızda, bağımsız bir iş parçacığı havuzuna sahip yeni bir dağıtıcı oluştururuz. Bu
yeni dağıtıcı, Dispatchers.IO sınırlarından tamamen bağımsızdır.
Buna karşılık, eğer limitedParallelism fonksiyonunu Dispatchers.Default veya başka bir dağıtıcı üzerinde
kullanırsak, orijinal dağıtıcıdaki sınırı koruyan, ancak ek bir sınıra sahip yeni bir dağıtıcı oluşturmuş oluruz.
Yani, Dispatchers.Default üzerinde limitedParallelism kullanıldığında, oluşturulan yeni dağıtıcı hala orijinal
sınırların içinde çalışır ve bağımsız bir havuz oluşturmaz.
 
// Sınırsız thread havuzuna sahip  dispatcher (temel thread havuzu)
private val pool = ...
 
Dispatchers.IO =   Thread havuzunu 64 thread ile sınırlar

Dispatchers.IO.limitedParallelism(x) = Thread Havuzu x degeri ile sınırlandırıldı

Dispatchers.Default = CPU çekirdek sayısı kadar thread ile sınırlıdır

Dispatchers.Default.limitedParallelism(x) = 
    Default'un thread sayısını x ile sınırlar
![![Dispatchers.Default, işlemci çekirdek sayısı ile sınırlıdır. Dispatchers.IO, 64 iş parçacığı (veya çekirdek sayısı) ile sınırlıdır. Dispatchers.Default üzerinde
limitedParallelism kullanıldığında, Dispatchers.Default’a ek bir sınır getiren bir dağıtıcı oluşturulur. Buna karşılık, Dispatcher.IO üzerinde
limitedParallelism kullanıldığında, Dispatchers.IO’dan tamamen bağımsız bir sınırı olan bir dağıtıcı oluşturulur. Ancak, tüm bu dağıtıcılar aynı sınırsız iş parçacığı havuzunu paylaşır.]]
(dispatchers_pools.png)
Birçok geliştirici, limitedParallelism fonksiyonunun Dispatchers.IO için farklı bir davranış sergilemesini kafa
karıştırıcı bulmaktadır. Bunun nedeni, limitedParallelism ile oluşturulan sınırlamanın Dispatchers.IO sınırıyla
doğrudan bir ilgisinin olmamasıdır. Bu durumu akla takrib için, bağımsız bir iş parçacığı sınırı olan
bir dağıtıcı oluşturmayı açıkça belirten basit bir fonksiyon ekleyebiliriz:
/** * Belirtilen thread limitiyle sınırlı özel bir dispatcher oluşturur. * Bu, farklı iş tipleri için ayrı thread havuzları oluşturmayı sağlar. * * @param threadLimit Maksimum eşzamanlı thread sayısı * @return Thread sayısı sınırlı bir CoroutineDispatcher */ fun limitedDispatcher(threadLimit: Int) = Dispatchers.IO .limitedParallelism(threadLimit)
İş parçacıklarını yoğun bir şekilde engelleyebilecek sınıflar için en iyi uygulama, kendi bağımsız sınırlarına sahip
özel dağıtıcılar tanımlamaktır. Bu sınır ne kadar büyük olmalıdır? Bunun kararını kendiniz vermelisiniz, ancak unutmayın
ki çok fazla iş parçacığı kullanımı, kaynaklarımızın verimsiz kullanımına yol açabilir. Öte yandan, uygun bir iş
parçacığı bulunmasını beklemek de performans açısından istenmeyen bir durumdur. En önemli nokta, belirlenen sınırın
Dispatchers.IO ve diğer bir servis, başka bir servisin işlemlerini engellemez.
/** * Diskten kullanıcı verilerini okuyan repository sınıfı. * * @param discReader Disk okuma işlemlerini gerçekleştiren servis */ class DiscUserRepository( private val discReader: DiscReader ) : UserRepository { /** * Disk I/O işlemleri için maksimum 5 thread ile sınırlandırılmış özel dispatcher. * Not: Doğru metot adı 'limitedParallelism' olmalıdır, mevcut kod hatalıdır. */ private val dispatcher = Dispatchers.IO .limitParallelism(5) /** * Disk üzerinden kullanıcı verilerini asenkron olarak okur. * Özel thread havuzunu kullanarak I/O işlemlerini gerçekleştirir. * * @return Disk üzerinden okunan kullanıcı verisi */ override suspend fun getUser(): UserData = withContext(dispatcher) { UserData(discReader.read("userName")) } }
Haber bülteni gönderme ve kayıt onay e-postaları örneğine geri dönelim. Bu hizmetlerin her biri, kendi sınırına sahip
bir dağıtıcıya (dispatcher) sahip olmalıdır. Bu sayede birbirlerini engellemezler. Buradaki asıl soru, bu sınırların ne
kadar büyük olması gerektiğidir. Ancak bunun basit bir cevabı yoktur. Bu, performans mı yoksa kaynak kullanımı mı daha
önemli sorusuna bağlıdır. Eğer performansı ön planda tutuyorsak, sınırı çoğu zaman kullanılacak iş parçacığı sayısına
göre ayarlamalıyız. Eğer kaynak kullanımını önemsiyorsak, sınırı en yoğun zamanlarda kullanılacak iş parçacığı sayısına
göre belirlemeliyiz. Bu durumda, haber bültenlerinin gönderilmesinin biraz daha uzun sürmesi benim için sorun teşkil
etmeyecektir; hatta bir saat sürse bile kabul edilebilir olur. Bu nedenle, bu iş için küçük bir sınır, örneğin 5,
kullanabilirim. Öte yandan, kayıt onay e-postalarının mümkün olduğunca hızlı gönderilmesini istiyorum ve bu hizmetin
aşırı yoğun şekilde kullanılacağını düşünmüyorum. Bu yüzden daha büyük bir sınır, örneğin 50, belirleyebilirim. Ancak,
en uç durumlarda bile çok fazla iş parçacığını engellemek istemem. Çünkü bu, saldırılara karşı savunmasız hale gelmemize
neden olabilir (çok fazla istek, yeterli sayıda iş parçacığını engelleyerek bellek taşmalarına(out-of-memory)yol
açabilir).
// NewsletterService sınıfı toplu e-posta (bülten) gönderimini yönetir class NewsletterService { // En fazla 5 paralel işleme izin veren özel dispatcher // Bu, API rate limit'leri aşmamak için önemli private val dispatcher = Dispatchers.IO.limitedParallelism(5) // E-posta gönderimi için SendGrid servisini kullanıyoruz private val sendGrid = SendGrid(API_KEY) // Bir bülteni birden çok e-posta adresine gönderen suspend fonksiyon suspend fun sendNewsletter( newsletter: Newsletter, emails: List<Email> ) = withContext(dispatcher) { // Listedeki her adres için paralel coroutine başlatır // Fakat dispatcher sayesinde aynı anda en fazla 5 tanesi çalışır emails.forEach { email -> launch { // Her adres için özelleştirilmiş bülten oluşturup gönder sendGrid.api(createNewsletter(email, newsletter)) } } } // ... } // AuthorizationService kullanıcı doğrulama e-postaları göndermekten sorumlu class AuthorizationService { // 50 paralel işleme izin veren dispatcher // Doğrulama e-postaları kritik olduğundan daha yüksek limit kullanılmış private val dispatcher = Dispatchers.IO.limitedParallelism(50) // Tek bir kullanıcıya doğrulama e-postası gönderen fonksiyon suspend fun sendAuthEmail( user: User ) = withContext(dispatcher) { // Kullanıcı için doğrulama e-postası oluştur ve gönder sendGrid.api(createConfirmationEmail(user)) } // ... }

Sabit İş Parçacığı Havuzuna Sahip Dağıtıcı (Dispatcher)

Bazı geliştiriciler, kullandıkları iş parçacığı havuzları üzerinde daha fazla kontrol sahibi olmayı tercih eder ve Java,
bu amaçla oldukça güçlü bir API sunar. Örneğin, Executors sınıfını kullanarak sabit veya önbellekli bir iş parçacığı
havuzu oluşturabiliriz. Bu havuzlar, ExecutorService veya Executor arayüzlerini uygular ve asCoroutineDispatcher
fonksiyonu kullanılarak bir dağıtıcıya (dispatcher) dönüştürülebilir.
// Sabit sayıda thread içeren bir thread havuzu tanımlıyoruz private val NUMBER_OF_THREADS = 20 // Java'nın Executors sınıfını kullanarak 20 threadlik sabit bir thread havuzu oluşturuyoruz // ve bunu Kotlin coroutine dispatcher'ına dönüştürüyoruz val dispatcher = Executors // 20 threadlik sabit bir thread havuzu oluştur .newFixedThreadPool(NUMBER_OF_THREADS) // Java ExecutorService'i Kotlin CoroutineDispatcher'a dönüştür .asCoroutineDispatcher()
limitedParallelism, kotlinx-coroutines kütüphanesinin 1.6 sürümünde tanıtılmıştır.
Önceki sürümlerde, bağımsız iş parçacığı havuzlarına sahip dağıtıcılar genellikle Executors sınıfı kullanılarak
oluşturuluyordu.
Bu yaklaşımın en büyük dezavantajı, ExecutorService.asCoroutineDispatcher() ile oluşturulan bir dağıtıcının close
fonksiyonu ile kapatılmasının gerekmesidir.Geliştiriciler sıklıkla bu adımı unutmaktadır ve bu da iş parçacıklarının
sızıntısına (thread leak) yol açmaktadır. Bir diğer sorun ise, sabit sayıda iş parçacığı içeren bir havuz
oluşturulduğunda, kaynakların verimli şekilde kullanılamamasıdır. Kullanılmayan iş parçacıkları, diğer servislerle
paylaşılmadan boşa çalıştırılmaya devam eder.

Tek İş Parçacığı ile Sınırlı Dağıtıcı (Dispatcher)

Çok iş parçacıklı dağıtıcılar kullanıldığında, paylaşılan durum sorunu dikkate alınmalıdır.
Aşağıdaki örnekte, 10.000 eşzamanlı işlem i değişkenini 1 artırmaktadır.
Teorik olarak, i değişkeninin değeri 10.000 olmalıdır, ancak daha küçük bir değer elde edilir.
Bunun nedeni, birden fazla iş parçacığının aynı anda paylaşılan değişken üzerinde değişiklik yapmasıdır.
Bu durum veri tutarsızlığı sorununa yol açar.
import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.coroutineScope import kotlinx.coroutines.delay import kotlinx.coroutines.launch //Örnek Başlangıcı // Global bir değişken, tüm coroutine'ler arasında paylaşılacak var i = 0 // Ana fonksiyon suspend olarak işaretlenmiş, bu sayede coroutine'ler içinde çalışabilir suspend fun main(): Unit = coroutineScope { // 10.000 kez tekrar eden bir döngü repeat(10_000) { // Her döngüde Dispatchers.IO thread havuzunda yeni bir coroutine başlatılıyor // Yorum'da belirtildiği gibi Dispatchers.Default da kullanılabilir launch(Dispatchers.IO) { // veya Default // Her coroutine 'i' değişkenini bir artırıyor // Bu işlem thread-safe değil (senkronize edilmemiş) i++ } } // Ana coroutine 1000 milisaniye (1 saniye) bekliyor // Bu süre içinde başlatılan diğer coroutine'lerin çoğunluğunun tamamlanması bekleniyor delay(1000) // 'i' değişkeninin son değeri yazdırılıyor // Not: ~9930 değeri beklenirken, bu tam 10.000 değil çünkü: // 1. Bazı coroutine'ler henüz tamamlanmamış olabilir // 2. 'i++' işlemi atomic değil, bu nedenle race condition'lar oluşabilir println(i) // ~9930 } //Örnek Sonu
Bu sorunu çözmenin birçok yolu vardır (Paylaşılan Durumlarla İlgili Sorunlar bölümünde daha ayrıntılı ele alınacaktır)
,ancak olası çözümlerden biri, yalnızca tek bir iş parçacığı kullanan bir dağıtıcı (dispatcher) kullanmaktır.Eğer aynı
anda yalnızca tek bir iş parçacığı kullanılırsa, ek bir senkronizasyon mekanizmasına gerek kalmaz.
Klasik yöntem, Executors kullanarak böyle bir dağıtıcı oluşturmaktı.Ancak, bu yöntem bir iş parçacığını sürekli aktif
tutar ve artık kullanılmadığında kapatılması gerekir.Daha modern bir çözüm olarak, iş parçacıklarını engellememek için
Dispatchers.Default veya Dispatchers.IOkullanılarak ve paralelliği 1 ile sınırlandırarak tek iş parçacıklı bir
dağıtıcı oluşturulabilir.
val dispatcher = Dispatchers.IO .limitedParallelism(1) // Eski yöntem: // val dispatcher = Executors.newSingleThreadExecutor() // .asCoroutineDispatcher()
import kotlinx.coroutines.* //Örnek Başlangıcı // Global bir sayaç değişkeni var i = 0 // Ana coroutine kapsamında çalışan suspend fonksiyon suspend fun main(): Unit = coroutineScope { // Dispatchers.Default dispatcher'ını limitedParallelism ile sınırlandırıyoruz // limitedParallelism(1) -> maksimum 1 iş parçacığı kullanılabilir // Bu, tüm coroutine'lerin aynı tek thread üzerinde sırayla çalışacağı anlamına gelir val dispatcher = Dispatchers.Default .limitedParallelism(1) // 10000 kez tekrar edecek bir döngü repeat(10000) { // Özel dispatcher ile yeni coroutine başlatılıyor // Tüm coroutine'ler aynı tek thread üzerinde çalışacak launch(dispatcher) { // Artırma işlemi, tek bir thread üzerinde olduğu için // artık thread-safe olacaktır i++ } } // Ana coroutine 1 saniye bekliyor // Bu süre boyunca diğer coroutine'lerin tamamlanmasını bekliyoruz delay(1000) // Sayacın değerini yazdır // Şimdi sonuç her zaman 10000 olacak çünkü: // 1. Tüm coroutine'ler aynı tek thread üzerinde sırayla çalışıyor // 2. Artırma işlemleri üst üste binmiyor (race condition yok) println(i) // 10000 } //Örnek Sonu
Tek bir iş parçacığı ile sınırlı bir dağıtıcı (dispatcher) kullanmanın en büyük dezavantajı, eğer bu iş parçacığını
engellersek çağrıların ardışık olarak işlenecek olmasıdır.
import kotlinx.coroutines.* import kotlin.system.measureTimeMillis // Ana coroutine kapsamında çalışan suspend fonksiyon suspend fun main(): Unit = coroutineScope { // Dispatchers.Default dispatcher'ını limitedParallelism ile sınırlandırıyoruz // limitedParallelism(1) -> maksimum 1 iş parçacığı kullanılabilir val dispatcher = Dispatchers.Default .limitedParallelism(1) // Özel dispatcher ile bir coroutine başlatıyoruz ve referansını saklıyoruz val launch = launch(dispatcher) { // Bu coroutine içinde 5 kez tekrar ediyoruz repeat(5) { // Her bir tekrarda YENİ BİR coroutine başlatıyoruz // DİKKAT: Bu iç coroutine'ler için özel bir dispatcher belirtilmemiş // Bu nedenle bu iç coroutine'ler üst coroutine'in dispatcher'ını DEĞİL, // varsayılan dispatcher'ı (Dispatchers.Default) kullanır ve PARALEL çalışabilirler launch { // Her bir iç coroutine, thread'i 1 saniye boyunca bloklayacak // NOT: Coroutine bağlamında Thread.sleep kullanmak iyi bir pratik değildir // Bunun yerine delay() kullanılmalıdır, ancak bu örnekte özellikle // thread'in bloklanması gösterilmektedir Thread.sleep(1000) } } } // Ana coroutine, başlattığımız dış coroutine'in tamamlanmasını bekliyor // ve bu işlemin ne kadar sürdüğünü ölçüyor val time = measureTimeMillis { launch.join() } // Ölçülen süreyi yazdırıyoruz // Sonuç yaklaşık 5 saniye olacak çünkü 5 iç coroutine PARALEL çalışıyor println("Took $time") // Took 5006 }

Project Loom'dan Gelen Sanal İş Parçacıklarını Kullanma

JVM platformu, Project Loom olarak bilinen yeni bir teknoloji sunmuştur2. Bu teknolojinin en büyük yeniliği,
geleneksel iş parçacıklarına kıyasla çok daha hafif olan sanal iş parçacıkları (virtual threads) kavramını
getirmesidir. Sanal iş parçacıklarının engellenmesi, geleneksel iş parçacıklarının engellenmesine kıyasla çok daha düşük
bir maliyetle gerçekleşmektedir.
Project Loom, Kotlin Coroutines'ı etkin bir şekilde kullanan geliştiriciler için büyük bir avantaj sunmamaktadır, çünkü
Kotlin Coroutines zaten zahmetsiz iptal mekanizmaları ve test süreçlerinde sanal zaman yönetimi gibi oldukça gelişmiş
özellikler sağlamaktadır3. Ancak, Project Loom’un sanal iş parçacıkları, Dispatchers.IO yerine kullanılabilir
ve iş parçacıklarının engellenmesinin kaçınılmaz olduğu durumlarda faydalı olabilir4.
Project Loom'u kullanabilmek için, JVM'in 19 veya daha üst bir sürümünü çalıştırmak gereklidir. Ayrıca, ön izleme
özelliklerini etkinleştirmek için --enable-preview bayrağının kullanılması zorunludur. Daha sonra, Executors
sınıfındaki newVirtualThreadPerTaskExecutor metoduyla bir yürütücü (executor) oluşturabilir ve bunu bir coroutine
dağıtıcısına dönüştürebiliriz.
// Project Loom'un sanal thread'lerini kullanan bir CoroutineDispatcher tanımlıyoruz val LoomDispatcher = Executors // Java 21'de tanıtılan, her görev için yeni bir sanal thread oluşturan bir executor .newVirtualThreadPerTaskExecutor() // Java Executor'ını Kotlin CoroutineDispatcher'a dönüştüren extension fonksiyon .asCoroutineDispatcher()
Bu tür bir dağıtıcı, nesne bildirimi (object declaration) kullanılarak da uygulanabilir:
// LoomDispatcher, bir singleton (tek örnek) nesne olarak tanımlanmış // ve ExecutorCoroutineDispatcher sınıfından türetilmiştir // Bu sayede Kotlin coroutine'leri ile Java sanal thread'leri arasında köprü görevi görür object LoomDispatcher : ExecutorCoroutineDispatcher() { // Java Executor arayüzünü uygulayan, sanal thread başlatan bir executor tanımlıyoruz // Bu executor, her çağrıldığında yeni bir sanal thread başlatacak override val executor: Executor = Executor { command -> // Her görev için yeni bir sanal thread oluşturulur Thread.startVirtualThread(command) // Sanal thread'ler platform thread'lerine göre çok daha hafiftir ve milyonlarca oluşturulabilir } // dispatch metodu, coroutine'lerin çalışma zamanı tarafından çağrılır // Bu metod, bir coroutine bloğunu çalıştırmak için gerekli işlemleri gerçekleştirir override fun dispatch( // Coroutine'in bağlamı context: CoroutineContext, // Çalıştırılacak coroutine bloğu block: Runnable ) { // Yukarıda tanımladığımız executor'ı kullanarak bloğu çalıştırırız executor.execute(block) // Bu, pratik olarak her coroutine bloğunun yeni bir sanal thread üzerinde çalışacağı anlamına gelir } // close metodu, dispatcher'ın kaynaklarını serbest bırakmak için kullanılır // Bu özel dispatcher'da, kapatma işlemine izin vermiyoruz override fun close() { error("Dispatchers.LOOM üzerinde çağrılamaz") // Hata fırlatarak kapatma denemelerini engelliyoruz // Çünkü bu dispatcher singleton olduğundan ve sanal thread'lerin yaşam döngüsünü // JVM kendisi yönettiğinden, manuel kapatmaya gerek yoktur } }
Bu dağıtıcıyı diğer dağıtıcılar gibi kullanabilmek için, Dispatchers nesnesi üzerinde bir genişletme özelliği
tanımlayabiliriz. Bu, aynı zamanda bu dağıtıcının keşfedilebilirliğini artıracaktır.
// Dispatchers sınıfına bir extension property (genişletme özelliği) ekliyoruz // Bu, Dispatchers.Loom şeklinde erişilebilen yeni bir özellik tanımlar val Dispatchers.Loom: CoroutineDispatcher // Bu özelliğe erişildiğinde LoomDispatcher nesnesini döndürür get() = LoomDispatcher
Şimdi, yeni dağıtıcımızın gerçekten bir iyileştirme olup olmadığını test etmemiz gerekiyor. Beklentimiz, iş
parçacıklarını (thread) engellediğimizde diğer dağıtıcılara kıyasla daha az bellek ve işlemci süresi tüketmesidir. Bunun
için ya hassas ölçümler yapabileceğimiz bir test ortamı kurabiliriz ya da farkın herkes tarafından gözlemlenebileceği
aşırı bir senaryo oluşturabiliriz. Bu kitapta, ikinci yaklaşımı tercih ettim.
100.000 eşzamanlı işlem başlatarak her birini 1 saniye boyunca engelledim. Bunların başka bir işlem yapması, örneğin
ekrana bir şey yazdırması veya bir değeri artırması, sonucu önemli ölçüde değiştirmezdi. Bu işlemlerin tamamının
Dispatchers.Loom üzerinde çalıştırılması yaklaşık iki saniye sürdü.
suspend fun main(): Unit = measureTimeMillis { coroutineScope { repeat(100_000) { launch(Dispatchers.Loom) { Thread.sleep(1000) } } } }.let(::println) // 2 273
Bu yeni dağıtıcıyı alternatif bir seçenekle karşılaştıralım. Dispatchers.IOyu doğrudan kullanmak adil olmaz, çünkü 64
iş parçacığı ile sınırlıdır ve bu durumda işlevin tamamlanması 26 dakikadan fazla sürecektir. Bunun yerine, iş parçacığı
sınırını eşzamanlı işlemlerin (coroutine) sayısına yükseltmeliyiz. Bu sınırı artırarak testi gerçekleştirdiğimde, kodun
yürütülmesi 23 saniyeden fazla sürdü, yani Dispatchers.Loom
sürümüne kıyasla on kat daha uzun. Ayrıca, Dispatchers.IO sürümü çok daha fazla bellek ve işlemci süresi tüketti. Bu
nedenle, mümkün olduğunda Dispatchers.IO yerine Dispatchers.Loom kullanmalıyız.
import kotlinx.coroutines.* import kotlin.system.measureTimeMillis // Bu bir suspend fonksiyonu, yani asenkron ve coroutine içinden çağrılabilir // main fonksiyonu tüm işlemin ne kadar sürdüğünü ölçmek için measureTimeMillis içine alınmış suspend fun main(): Unit = measureTimeMillis { // coroutineScope, içindeki tüm coroutine'ler tamamlanana kadar bekler coroutineScope { // 100.000 kez aynı işlemi tekrar eder repeat(100_000) { // Her tekrarda Loom Dispatcher kullanarak yeni bir coroutine başlatır launch(Dispatchers.Loom) { // Her coroutine 1 saniye bekler Thread.sleep(1000) } } } // Tüm coroutine'ler tamamlandıktan sonra ölçüm biter }.let(::println) // Ölçülen süreyi (milisaniye cinsinden) konsola yazdırır, sonuç: 2273 ms
Şu an itibariyle, Project Loom hâlâ yeni ve kullanımı zor, ancak Dispatchers.IO için heyecan verici bir alternatif
olduğunu söylemeliyim. Bununla birlikte, gelecekte bunu doğrudan kullanmanız gerekmeyecek, çünkü Kotlin Coroutines
ekibi, Project Loom stabil hâle geldiğinde sanal iş parçacıklarını varsayılan olarak kullanmayı planladıklarını
belirtti. Umarım bu süreç en kısa sürede gerçekleşir.

Bağlı Olmayan Dağıtıcı (Unconfined Dispatcher)

Ele almamız gereken son dağıtıcı Dispatchers.Unconfineddir. Bu dağıtıcı, diğer dağıtıcılardan farklıdır çünkü herhangi
bir iş parçacığını değiştirmez. Başlatıldığında, hangi iş parçacığında başlatıldıysa onun üzerinde çalışır. Eğer askıya
alınıp yeniden devam ettirilirse, onu devam ettiren iş parçacığı üzerinde çalışmaya devam eder.
import kotlinx.coroutines.* import kotlin.concurrent.thread import kotlin.coroutines.Continuation import kotlin.coroutines.resume //Örnek Başı fun main() { // Coroutine'i devam ettirebilmek için gerekli olan continuation referansını saklayacak değişken var continuation: Continuation<Unit>? = null // "Thread1" adında yeni bir thread başlatıyoruz thread(name = "Thread1") { // Dispatcher.Unconfined kullanarak bir coroutine başlatıyoruz // Unconfined dispatcher, coroutine'in başladığı thread'de çalışır ve suspend noktalarından // sonra çağıran thread'de devam eder runBlocking(Dispatchers.Unconfined) { // İlk başta Thread1 üzerinde çalışıyoruz println(Thread.currentThread().name) // Thread1 yazdırır // suspendCancellableCoroutine fonksiyonu, coroutine'i askıya alır ve continuation // nesnesini lambda fonksiyonuna sağlar suspendCancellableCoroutine { // Continuation'ı daha sonra kullanmak üzere saklıyoruz continuation = it // Buradan sonra coroutine askıya alınır ve continuation.resume çağrılana kadar bekler } // Coroutine tekrar başladığında, şimdi Thread2 üzerinde çalışıyoruz // Çünkü continuation.resume Thread2 üzerinden çağrıldı println(Thread.currentThread().name) // Thread2 yazdırır // delay fonksiyonu da bir suspend fonksiyonudur delay(1000) // delay sonrası coroutine yeniden başladığında artık kotlinx.coroutines.DefaultExecutor // üzerinde çalışıyoruz, çünkü delay bu executor'ı kullanır println(Thread.currentThread().name) // kotlinx.coroutines.DefaultExecutor yazdırır } } // "Thread2" adında başka bir thread başlatıyoruz thread(name = "Thread2") { // 1 saniye bekliyoruz Thread.sleep(1000) // Askıya alınmış coroutine'i devam ettiriyoruz // Bu çağrı coroutine'in Thread2 üzerinde devam etmesini sağlar continuation?.resume(Unit) } } //Örnek Sonu
Eski projelerde, birim testlerinde Dispatchers.Unconfined kullanımına rastlamak mümkündür. Örneğin, launch çağıran
bir fonksiyonu test etmek istediğinizi düşünelim; zaman senkronizasyonu sağlamak kolay olmayabilir. Bunun bir çözümü,
diğer tüm dağıtıcılar yerine Dispatchers.Unconfined kullanmaktır. Eğer tüm kapsamlar (scope) içinde bu dağıtıcı
kullanılırsa, her şey aynı iş parçacığı üzerinde çalışır ve işlem sırasını daha kolay kontrol edebiliriz. Ancak bu
yöntem artık gereksizdir, çünkü Kotlin Coroutines için test yaparken kullanabileceğimiz çok daha iyi araçlar
bulunmaktadır. Bu konuyu kitabın ilerleyen bölümlerinde ele alacağız.
Performans açısından bakıldığında, Dispatchers.Unconfined en hafif dağıtıcıdır, çünkü iş parçacıkları arasında geçiş
yapmaya gerek duymaz. Bu nedenle, kodumuzun hangi iş parçacığında çalıştığını önemsemediğimiz durumlarda tercih
edilebilir. Ancak, pratikte bu dağıtıcıyı rastgele kullanmak iyi bir yaklaşım olarak kabul edilmez. Peki ya yanlışlıkla
bir engelleyici (blocking) işlem çağırırsak ve işlem Main iş parçacığında çalışıyorsa? Bu durum, tüm uygulamanın
donmasına neden olabilir. İşte bu yüzden, Dispatchers.Unconfined üretim kodlarında özel durumlar dışında
kullanılmamalıdır.

Anında Ana İş Parçacığı Görevlendirmesi (Immediate Main Dispatching)

Bir eşzamanlı işlemi (coroutine) görevlendirmenin belirli bir maliyeti vardır. withContext çağrıldığında, işlem askıya
alınmalı, olası bir sıraya alınmalı ve ardından tekrar devam ettirilmelidir. Eğer zaten aynı iş parçacığı üzerinde
çalışıyorsak, bu küçük ama gereksiz bir maliyettir. Aşağıdaki fonksiyona göz atalım:
// Bu bir suspend fonksiyon, bu nedenle sadece bir coroutine içinden veya // başka bir suspend fonksiyonundan çağrılabilir suspend fun showUser(user: User) = // withContext, belirtilen dispatcher'da kod bloğunu çalıştırır ve // bloğun son ifadesini döndürür withContext(Dispatchers.Main) { // Dispatchers.Main, ana UI thread'i üzerinde çalışır // Bu satır kullanıcı adını UI elemanına atar userNameElement.text = user.name // Burada diğer UI güncellemeleri olabilir // ... }
Eğer bu fonksiyon zaten ana iş parçacığında (Main dispatcher) çağrılmış olsaydı, gereksiz bir yeniden görevlendirme
maliyeti oluşurdu. Daha da önemlisi, withContext nedeniyle ana iş parçacığında uzun bir işlem kuyruğu oluşursa,
kullanıcı verileri gecikmeli olarak gösterilebilir (çünkü bu eşzamanlı işlem, diğer işlemlerin tamamlanmasını beklemek
zorunda kalacaktır). Bunu önlemek için Dispatchers.Main.immediate kullanılır. Bu yapı, yalnızca gerektiğinde iş
parçacığını yeniden görevlendirir. Böylece, aşağıdaki fonksiyon eğer zaten ana iş parçacığında çağrılmışsa, tekrar
görevlendirilmez ve doğrudan çalıştırılır.
suspend fun showUser(user: User) = // withContext, belirtilen dispatcher'da kod bloğunu çalıştırır withContext(Dispatchers.Main.immediate) { // Dispatchers.Main.immediate ana UI thread'i üzerinde çalışır, // "immediate" özelliği sayesinde eğer zaten Main thread'deyse // gereksiz dispatcher değişimini atlar ve kodu anında çalıştırır userNameElement.text = user.name // Burada diğer UI güncellemeleri olabilir // ... }
Bir fonksiyonun zaten ana iş parçacığında (Main dispatcher) çağrılmış olabileceği bir durumda withContext
kullanmamız gerekiyorsa, argüman olarak Dispatchers.Main.immediate tercih edilir. Bu sayede, eğer mevcut iş parçacığı
zaten Main dispatcher ise, gereksiz bir yeniden görevlendirme işlemi yapılmaz ve işlem doğrudan çalıştırılır.
Şu an itibariyle, diğer dağıtıcılar (dispatchers) anında görevlendirme (immediate dispatching) desteği sunmamaktadır.

Devamlılık (Continuation) Kesici

Görevlendirme (dispatching) işlemi, Kotlin diline entegre edilmiş devamlılık kesme (continuation interception)
mekanizmasına dayanır. Bu bağlamda, ContinuationInterceptor adlı bir coroutine bağlamı (CoroutineContext)
bulunmaktadır. Bu bağlam, interceptContinuation metodunu kullanarak bir coroutine askıya alındığında (suspend
edildiğinde) devamlılığı (continuation) değiştirme yeteneğine sahiptir5.
Ayrıca, releaseInterceptedContinuation metodu, kesilmiş devamlılık işlemi sona erdiğinde çağrılır. Bu mekanizma,
coroutine'lerin farklı iş parçacıkları veya dağıtıcılar (dispatchers) üzerinde yönetilmesini sağlar.
// ContinuationInterceptor, CoroutineContext'in bir elementi olarak tanımlanmış // bir arayüzdür (interface). Coroutine'lerin execution akışını kontrol eder. public interface ContinuationInterceptor : CoroutineContext.Element { // Key sınıfı, CoroutineContext içindeki bu elementin anahtarıdır // Bu anahtar, context içinden ContinuationInterceptor'ı almak için kullanılır // Örn: context[ContinuationInterceptor] şeklinde erişilir companion object Key : CoroutineContext.Key<ContinuationInterceptor> // Bu metot, bir continuation'ı intercept eder (araya girer) ve ona müdahale edebilir // Orijinal continuation'ı alır ve genellikle onu sarmalayan (wrapping) özelleştirilmiş // bir continuation döndürür. Bu sarmalama, coroutine'in çalışma ortamını değiştirmek için kullanılır // Örneğin, belirli bir thread'e veya thread havuzuna dispatch etmek için fun <T> interceptContinuation( continuation: Continuation<T> ): Continuation<T> // Bu metot, intercepted (müdahale edilmiş) bir continuation'ı // kullanımdan sonra serbest bırakmak için çağrılır // Kaynak temizliği için fırsat sağlar. Varsayılan implementasyonu boştur, // ihtiyaç duyulduğunda interceptor tarafından override edilebilir fun releaseInterceptedContinuation( continuation: Continuation<*> ) { } //... (Diğer metotlar) }
Coroutine'in devamlılığını (continuation) sarmalama yeteneği, büyük bir kontrol imkanı sunar. Dağıtıcılar (dispatchers),
interceptContinuation metodunu kullanarak devamlılığı DispatchedContinuation ile sararlar. Bu yapı, belirli bir iş
parçacığı havuzunda çalışmasını sağlar ve dağıtıcıların temel çalışma prensibini oluşturur. Ancak aynı bağlam (context),
kotlinx-coroutines-test kütüphanesindeki runTest gibi birçok test kütüphanesi tarafından da kullanılır. Coroutine
bağlamındaki her elemanın benzersiz bir anahtarı (key) olması gerektiğinden, birim testlerinde genellikle dağıtıcıları
test dağıtıcılarıyla değiştirmek için bağlama enjekte ederiz. Bu konuya, coroutine testlerine ayrılmış bölümde daha
ayrıntılı olarak değineceğiz.
// Kullanıcı veritabanı işlemlerini gerçekleştiren repository sınıfı // Diskten kullanıcı verilerini okur ve UserRepository arayüzünü uygular class DiscUserRepository( // Disk okuma işlemlerini gerçekleştiren bileşen private val discReader: DiscReader, // İşlemlerin hangi coroutine bağlamında (thread'de) çalışacağını belirler // Varsayılan olarak Dispatchers.IO kullanılır (IO işlemleri için optimize edilmiş thread havuzu) private val dispatcher: CoroutineContext = Dispatchers.IO, ) : UserRepository { // Kullanıcı verisini asenkron olarak getiren suspend fonksiyon override suspend fun getUser(): UserData = // İşlemleri belirtilen dispatcher'a (genellikle IO thread) yönlendirir withContext(dispatcher) { // Diskten "userName" değerini okur ve UserData nesnesine dönüştürür UserData(discReader.read("userName")) } } // Repository sınıfının birim testlerini içeren test sınıfı class UserReaderTests { // Test fonksiyonu - runTest ile özel coroutine test ortamında çalıştırılır @Test fun `some test`() = runTest { // HAZIRLIK AŞAMASI (GIVEN) // Gerçek disk okuma işlemleri yerine test için özel sahte bir implementasyon kullanılır val discReader = FakeDiscReader() // Test edilecek repository örneği oluşturulur val repo = DiscUserRepository( discReader, // TEST ORTAMI ENTEGRASYONU // Test coroutine'inin dispatcher'ını kullanarak gerçek IO thread'leri yerine // test ortamının kontrolünde çalışmasını sağlarız // ContinuationInterceptor, dispatcher mantığını yöneten temel bileşendir this.coroutineContext[ContinuationInterceptor]!! ) //... (Test kodunun devamı) } }

Dağıtıcıların farklı görevlerdeki performansı

Farklı dağıtıcıların çeşitli görevlerde nasıl performans gösterdiğini göstermek için bazı karşılaştırmalar yaptım. Tüm
durumlarda, aynı görevi gerçekleştiren 100 bağımsız coroutine çalıştırılmıştır. Tablodaki sütunlar farklı görevleri
temsil etmektedir:
  • Bir saniye askıya alma (süreç bekleme)
  • Bir saniye engelleme (bloklama)
  • CPU yoğun işlemler
  • Bellek yoğun işlemler (çoğunlukla bellek erişimi, tahsis ve serbest bırakma sürecinde zaman harcayan işlemler)
Satırlar ise bu süreçlerin çalıştırıldığı farklı dağıtıcıları göstermektedir. Aşağıdaki tablo, ortalama yürütme süresini
milisaniye cinsinden göstermektedir.
Askıya almaEngellemeCPUBellek
Tek iş parçacığı1 002100 00339 10394 358
Default (8 iş parçacığı)1 00213 0038 47321 461
Giriş/Çıkış-IO (64 iş parçacığı)1 0022 0039 89320 776
100 iş parçacığı1 0021 00310 37921 004
Bu verilerden çıkarılabilecek bazı önemli gözlemler şunlardır:
  1. Süreç yalnızca askıya alınıyorsa, kullanılan iş parçacığı sayısı performans üzerinde belirgin bir etkiye sahip
    değildir.
  2. Engelleme işlemleri söz konusu olduğunda, kullanılan iş parçacığı sayısı arttıkça tüm süreçlerin tamamlanma süresi
    kısalır.
  3. CPU yoğun işlemler için Dispatchers.Default en verimli seçenektir6.
  4. Bellek yoğun işlemlerde, daha fazla iş parçacığı kullanımı belirli bir performans artışı sağlayabilir; ancak bu artış
    genellikle sınırlıdır ve önemli bir fark yaratmaz.
Aşağıda test edilen fonksiyonlar gösterilmektedir7:
// Yoğun CPU kullanımı gerektiren bir fonksiyon // CPU'yu yoğun şekilde kullanarak bir sipariş nesnesinden kahve üretir fun cpu(order: Order): Coffee { // Çok büyük bir sayıdan başlayarak yoğun hesaplama yapar var i = Int.MAX_VALUE while (i > 0) { // Sayının çift/tek durumuna göre farklı şekilde azaltarak CPU'yu yoğun çalıştırır i -= if (i % 2 == 0) 1 else 2 } // Hesaplama sonucunu kullanarak yeni bir Coffee nesnesi döndürür return Coffee(order.copy(customer = order.customer + i)) } // Yüksek bellek kullanımı gerektiren bir fonksiyon // Büyük nesneler oluşturarak belleği yoğun şekilde kullanır fun memory(order: Order): Coffee { // İç içe listeler oluşturarak bellek kullanımını artırır // 1. seviye liste val list = List(1_000) { it } // 2. seviye liste (liste içinde liste) val list2 = List(1_000) { list } // 3. seviye liste (liste içinde liste içinde liste) val list3 = List(1_000) { list2 } // Büyük listenin hash kodunu kullanarak Coffee nesnesi döndürür return Coffee( order.copy( customer = order.customer + list3.hashCode() ) ) } // Thread'i bloke eden fonksiyon // Thread.sleep() kullanarak çağrıldığı thread'i bloke eder fun blocking(order: Order): Coffee { // Thread'i 1 saniye durdurur (bloke eder) Thread.sleep(1000) // Siparişten kahve üretir return Coffee(order) } // Coroutine'i askıya alan (suspend) fonksiyon // delay() kullanarak coroutine'i askıya alır, thread'i bloke etmez suspend fun suspending(order: Order): Coffee { // Coroutine'i 1 saniye askıya alır, thread serbest kalır delay(1000) // Siparişten kahve üretir return Coffee(order) }

Özet

Dağıtıcılar, bir sürecin hangi iş parçacığında veya iş parçacığı havuzunda başlatılacağını ve yürütüleceğini belirleyen
önemli bileşenlerdir. Doğru dağıtıcı seçimi, eşzamanlı işlem yönetimi, kaynak kullanımı ve uygulama performansı
açısından kritik öneme sahiptir. Aşağıda en yaygın kullanılan dağıtıcılar ve kullanım alanları açıklanmaktadır:
  • Dispatchers.Default: Çok iş parçacıklı işlemci havuzunu (CPU-bound thread pool) kullanarak çalışır ve işlemci
    yoğun hesaplamalar gerektiren görevler için uygundur. İşlemci çekirdek sayısına bağlı olarak iş parçacıklarını
    ölçeklendirir, böylece optimum performans sağlar.
  • Dispatchers.Main: Android, Swing veya JavaFX gibi tek iş parçacıklı kullanıcı arayüzü (UI) odaklı platformlarda
    ana iş parçacığında çalışacak görevler için kullanılır. Kullanıcı arayüzü bileşenlerinin değiştirilmesi veya kullanıcı
    etkileşimlerinin yönetilmesi gibi işlemler bu bağlamda gerçekleştirilir.
  • Dispatchers.Main.immediate: Dispatchers.Main ile aynı iş parçacığında çalışır, ancak yürütülmesi gereken görev ana
    iş parçacığında zaten çalışıyorsa ek bir yeniden planlama (redispatching) gerçekleştirmez. Bu, gereksiz bağlam
    değişikliklerini (context switch) önleyerek işlem maliyetini düşürür.
  • Dispatchers.IO: Ağ, dosya okuma/yazma ve veritabanı erişimi gibi engelleyici (blocking) işlemler için optimize
    edilmiş bir iş parçacığı havuzu sağlar. Engelleyici işlemlerin ana iş parçacığında yürütülmesini önleyerek uygulamanın
    tepki süresini artırır.
  • Dispatchers.IO (sınırlı paralellik ile- limitedParallelism()) veya özel bir iş parçacığı havuzu: Çok sayıda
    engelleyici çağrının (
    örneğin, çok sayıda ağ isteğinin veya dosya işleminin) eş zamanlı olarak yürütülmesi gerektiğinde, belirli bir iş
    parçacığı sayısıyla sınırlandırılmış bir paralel çalışma modeli kullanılabilir. Böylece, iş parçacıklarının aşırı
    yüklenmesi engellenerek kaynak tüketimi dengelenir.
  • Dispatchers.Default veya Dispatchers.IO (paralellik 1 ile sınırlandırılmış-limitedParallelism(1)) ya da tek iş
    parçacıklı özel bir
    dağıtıcı: Paylaşılan veri durumunu değiştiren (shared state modification) işlemlerde kullanılır. Tek iş parçacıklı
    yürütme modeli, aynı anda birden fazla süreç tarafından değiştirilen ortak verinin tutarlılığını koruyarak veri yarış
    durumlarını (race condition) ve belirsiz davranışları önler.
  • Dispatchers.Unconfined: Sürecin hangi iş parçacığında yürütüleceğini başlangıçta belirlemez ve yürütme, çağıran iş
    parçacığında başlar. İşlem sürecinin devamında başka bir iş parçacığına aktarılması mümkündür. Genellikle belirli özel
    senaryolar ve optimizasyonlar için tercih edilir, ancak yanlış kullanımı beklenmeyen eşzamanlılık hatalarına neden
    olabilir.
Dağıtıcıların doğru seçilmesi, süreçlerin verimli ve öngörülebilir bir şekilde yürütülmesini sağlamak için gereklidir.
Bu seçim, uygulamanın türüne, yürütülen görevlerin özelliklerine ve performans gereksinimlerine bağlı olarak dikkatlice
yapılmalıdır.
  1. 1.Bu mekanizma belirli bir çıktı üretmeyen, deterministik olmayan bir yapıdadır. ↩
  2. 2.Bu ifadeyi iyimser bir bakış açısıyla yazıyorum; umuyorum ki bu metni okuduğunuzda Project Loom kararlı bir ↩
  3. 3.Bu konu, Kotlin Süreçlerinin Test Edilmesi bölümünde ayrıntılı olarak ele alınacaktır. ↩
  4. 4.Çözüm, Jan Vladimir Mostert tarafından yazılan [*Running Kotlin coroutines on Project Loom's virtual ↩
  5. 5.Önbellekleme mekanizması sayesinde her devamlılık için sarmalama işlemi yalnızca bir kez ↩
  6. 6.Bunun temel nedeni, daha fazla iş parçacığı kullanıldıkça işlemcinin bu iş parçacıkları arasında geçiş yapmak ↩
  7. 7.Tüm kod, şu adreste bulunabilir: https://kt.academy/dispatchers-benchmarks. ↩