
Bu metin, Kotlin Coroutines kitabının bir bölümüdür. Kitabın tamamına LeanPub üzerinden erişebilirsiniz
parçacığı havuzunda çalışacağını belirleme yeteneği sunar. Bu, iş parçacığı yöneticileri (dispatchers) kullanılarak
gerçekleştirilir.
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.
Dispatchers.Defaultatanır.
Dispatchers.Default, işlemci yoğunluklu (CPU-intensive) görevleri çalıştırmak için tasarlanmıştır.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.
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
Ç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,runBlockingkapsamı içinde çalıştırılan işlemler otomatik olarakDispatchers.Defaultkullanmaz.
Eğer yukarıdaki örnektecoroutineScopeyerinerunBlockingkullansaydık,
tüm işlemler"main"iş parçacığında çalışacaktı.
Dispatchers.Default tarafından kullanılan tümiş parçacıklarını (threads) tüketerek aynı dağıtıcıyı kullanan diğer eşzamanlı işlemleri engelleyebileceğinden
şüpheleniyorsunuz.
Dispatchers.Default üzerinde limitedParallelism fonksiyonunu kullanarak bir sınırlandırmagetirebiliriz. 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.
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)
limitedParallelism fonksiyonunu gördüyseniz, Dispatchers.Default ile Dispatchers.IO üzerindetamamen farklı bir davranış sergilediğini bilmelisiniz. Bu farkları ilerleyen bölümlerde detaylı olarak ele alacağız.
limitedParallelism, kotlinx-coroutines kütüphanesinin1.6sürümüyle birlikte tanıtılmıştır. Bu nedenle, eski
projelerde bu fonksiyonun kullanımına rastlamayabilirsiniz.
ana iş parçacığı(Main Thread) kavramına sahiptir. Android’de bu iş parçacığı özellikle önemlidir çünkü UIgü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çinDispatchers.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ığı eklenereketkinleştirilebilir. Benzer şekilde, JavaFX için
kotlinx-coroutines-javafx, Swing için ise kotlinx-coroutines-swingbağı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) genelliklekullanılmaz. Bu nedenle, test ortamında
Dispatchers.Main varsayılan olarak tanımlı değildir. Birim testlerindeDispatchers.Main kullanabilmek için kotlinx-coroutines-test kütüphanesinde yer alanDispatchers.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. } } }
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 veDispatchers.Default yeterli olur.- 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ı.
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ükG/Ç işlemlerini daha verimli bir şekilde yürütmek için tasarlanmış bir iş parçacığı havuzu sağlar.
Dispatchers.IO, iş parçacıklarını engelleyen (blocking) G/Ç (I/O) işlemleri için tasarlanmıştır. Örneğin, dosyaokuma/yazma işlemleri veya engelleyici (blocking) fonksiyon çağrıları gibi işlemler için kullanılır.
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.IOyalnı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.IOkullanmanıza gerek yoktur. Bu nedenle, birçok projedeDispatchers.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.
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
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 eder1Bu mekanizma belirli bir çıktı üretmeyen, deterministik olmayan bir yapıdadır..Ancak burada değişen şey, iş parçacığının
Dispatchers.Default sınırı yerine Dispatchers.IO sınırına dahil olmasıdır.Böylece CPU yoğun işlemler (
Dispatchers.Default) ve bloklayan IO işlemleri (Dispatchers.IO) birbirleriniengellemeden 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
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 vesisteminizde 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 çoksayı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çilirve 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ş) // ... }
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, öncelikliolarak 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.
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.
bağımsızdır. Bu sayede,
limitedParallelism kullanarak farklı görevler için belirli bir iş parçacığı sınırı belirlemekmü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") }
Dispatchers.Default ve Dispatchers.IO tarafından kullanılan sınırsız bir iş parçacığı havuzuvardır, ancak her iki dağıtıcı da bu iş parçacıklarına sınırlı erişime sahiptir.
Dispatchers.IO üzerindelimitedParallelism kullandığımızda, bağımsız bir iş parçacığı havuzuna sahip yeni bir dağıtıcı oluştururuz. Buyeni dağıtıcı,
Dispatchers.IO sınırlarından tamamen bağımsızdır.limitedParallelism fonksiyonunu Dispatchers.Default veya başka bir dağıtıcı üzerindekullanı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 orijinalsı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
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 üzerindelimitedParallelism 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)
limitedParallelism fonksiyonunun Dispatchers.IO için farklı bir davranış sergilemesini kafakarıştırıcı bulmaktadır. Bunun nedeni,
limitedParallelism ile oluşturulan sınırlamanın Dispatchers.IO sınırıyladoğ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)
ö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")) } }
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)) } // ... }
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 asCoroutineDispatcherfonksiyonu 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-coroutineskü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 genellikleExecutorssınıfı kullanılarak
oluşturuluyordu.
ExecutorService.asCoroutineDispatcher() ile oluşturulan bir dağıtıcının closefonksiyonu 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.
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
,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.
Executors kullanarak böyle bir dağıtıcı oluşturmaktı.Ancak, bu yöntem bir iş parçacığını sürekli aktiftutar 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ı birdağı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
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 }
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.
Kotlin Coroutines zaten zahmetsiz iptal mekanizmaları ve test süreçlerinde sanal zaman yönetimi gibi oldukça gelişmiş
özellikler sağlamaktadır3Bu konu, Kotlin Süreçlerinin Test Edilmesi bölümünde ayrıntılı olarak ele alınacaktır.. Ancak, Project Loom’un sanal iş parçacıkları,
Dispatchers.IO yerine kullanılabilirve iş parçacıklarının engellenmesinin kaçınılmaz olduğu durumlarda faydalı olabilir4Çözüm, Jan Vladimir Mostert tarafından yazılan [*Running Kotlin coroutines on Project Loom's virtual.
özelliklerini etkinleştirmek için
--enable-preview bayrağının kullanılması zorunludur. Daha sonra, Executorssınıfındaki
newVirtualThreadPerTaskExecutor metoduyla bir yürütücü (executor) oluşturabilir ve bunu bir coroutinedağı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()
// 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 } }
Dispatchers nesnesi üzerinde bir genişletme özelliğitanı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
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.
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
Dispatchers.IOyu doğrudan kullanmak adil olmaz, çünkü 64iş 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.Loomsü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. Bunedenle, 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
Dispatchers.IO için heyecan verici bir alternatifolduğ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.
Dispatchers.Unconfineddir. Bu dağıtıcı, diğer dağıtıcılardan farklıdır çünkü herhangibir 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
Dispatchers.Unconfined kullanımına rastlamak mümkündür. Örneğin, launch çağıranbir 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.
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ındonmasına neden olabilir. İşte bu yüzden,
Dispatchers.Unconfined üretim kodlarında özel durumlar dışındakullanılmamalıdır.
withContext çağrıldığında, işlem askıyaalı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 // ... }
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 // ... }
withContextkullanmamı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.
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 (suspendedildiğinde) devamlılığı (continuation) değiştirme yeteneğine sahiptir5Önbellekleme mekanizması sayesinde her devamlılık için sarmalama işlemi yalnızca bir kez.
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) }
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. Coroutinebağ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ı) } }
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)
milisaniye cinsinden göstermektedir.
| Askıya alma | Engelleme | CPU | Bellek | |
|---|---|---|---|---|
| Tek iş parçacığı | 1 002 | 100 003 | 39 103 | 94 358 |
| Default (8 iş parçacığı) | 1 002 | 13 003 | 8 473 | 21 461 |
| Giriş/Çıkış-IO (64 iş parçacığı) | 1 002 | 2 003 | 9 893 | 20 776 |
| 100 iş parçacığı | 1 002 | 1 003 | 10 379 | 21 004 |
- Süreç yalnızca askıya alınıyorsa, kullanılan iş parçacığı sayısı performans üzerinde belirgin bir etkiye sahip
değildir. - 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. - CPU yoğun işlemler için
Dispatchers.Defaulten verimli seçenektir6Bunun temel nedeni, daha fazla iş parçacığı kullanıldıkça işlemcinin bu iş parçacıkları arasında geçiş yapmak. - 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.
// 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) }
ö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.DefaultveyaDispatchers.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.
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.Bu mekanizma belirli bir çıktı üretmeyen, deterministik olmayan bir yapıdadır. ↩
- 2.Bu ifadeyi iyimser bir bakış açısıyla yazıyorum; umuyorum ki bu metni okuduğunuzda Project Loom kararlı bir ↩
- 3.Bu konu, Kotlin Süreçlerinin Test Edilmesi bölümünde ayrıntılı olarak ele alınacaktır. ↩
- 4.Çözüm, Jan Vladimir Mostert tarafından yazılan [*Running Kotlin coroutines on Project Loom's virtual ↩
- 5.Önbellekleme mekanizması sayesinde her devamlılık için sarmalama işlemi yalnızca bir kez ↩
- 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.Tüm kod, şu adreste bulunabilir: https://kt.academy/dispatchers-benchmarks. ↩