Kotlin hangi çoklu iş parçacığı öğelerini sağlar…

Kotlin aşağıdaki çok iş parçacığı öğelerini sağlar:

Koritinler: Hafif iş parçacıkları, askıya alınabilir fonksiyonlara dayanır. Kodun asenkron ve engellemesiz yürütülmesini sağlar.

Koritin yapıcıları: Korutinleri başlatan fonksiyonlar. Anahtarlar: launch (değer döndürmeden korutin başlatır), async (korutin başlatır ve Deferred döndürür, sonucu almak için beklenebilir).

// launch kullanım örneği
GlobalScope.launch {
    println("Korutinden merhaba ${Thread.currentThread().name}")
}

// async kullanım örneği
val deferred = GlobalScope.async {
    delay(1000) // Uzun süren bir işlemi taklit eder
    "Sonuç"
}
val result = runBlocking { deferred.await() } // Sonucu bekler

Dispatchers: Korutinin çalışacağı işçi havuzunu belirler. Anahtarlar:
- Dispatchers.Default: CPU yoğun görevler için genel havuz.
- Dispatchers.IO: Giriş/Çıkış bloklayıcı işlemler için havuz (dosyalar, ağ).
- Dispatchers.Main: Kullanıcı arayüzü akışı için dispatcher (Android, Swing).
- Dispatchers.Unconfined: Korutin mevcut iş parçacığında başlar, ancak herhangi bir iş parçacığında devam edebilir.
```
GlobalScope.launch(Dispatchers.IO) {
    // Giriş/Çıkış işlemleri
}
```
runBlocking: Korutin yapıcı fonksiyon, mevcut iş parçacığını korutina tamamlanana kadar engeller. Bloke edici ve engelleyici olmayan kodu birleştirmek için kullanılır, genellikle testlerde veya main fonksiyonlarında.
```
runBlocking {
    launch {
        delay(500)
        println("${Thread.currentThread().name} içinde tamamlandı")
    }
    println("${Thread.currentThread().name} içinde başlatıldı")
}
```
suspend fonksiyonlar: Yürütülebilirliği askıya alınabilir ve devam ettirilebilir fonksiyonlar. Sadece diğer suspend fonksiyonlardan veya korutin yapıcılarından çağrılabilir.
```
suspend fun doSomething() {
    delay(100) // Askıya alma örneği
}
```
Job: Çalışmakta olan bir korutina için handle. Korutinin yaşam döngüsünü yönetmek için metodlar sağlar (iptal etme, tamamlanmayı bekleme).
```
val job = GlobalScope.launch {
   // Uzun işlem
}
job.cancel() // Korutini iptal et
runBlocking { job.join() } // Tamamlanmayı bekle
```
CoroutineScope: Korutinler için alan tanımlar. Belirli bir alanda başlatılan korutinler, alan iptal edildiğinde otomatik olarak iptal edilir. Yaşam döngüsünü yönetmeye yardımcı olur.
```
val scope = CoroutineScope(Dispatchers.Default)
scope.launch {
    // Bu alandaki korutin
}
scope.cancel() // Bu alandaki tüm korutinleri iptal et
```

Kanallar (Channel): Korutinalar arasında güvenli veri iletimi için primitive. Kanallar tek yönlü (sadece gönderme veya alma) veya çift yönlü olabilir.

import kotlinx.coroutines.channels.Channel

val channel = Channel<Int>()

runBlocking {
    launch {
        for (x in 1..5) channel.send(x * x)
        channel.close() // Kanalı kapatmak önemli
    }
    launch {
        for (y in channel) println(y)
    }
}

Mutex (Mutex): Eşzamanlama primitive'i, ortak kaynağa özel erişimi sağlar. İş parçacığı güvenliğini sağlar, yalnızca bir korutina aynı anda mutex'i sahip olabilir.

import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock

val mutex = Mutex()
var counter = 0

suspend fun incrementCounter() {
    mutex.withLock {
        counter++
    }
}

Durumlar (StateFlow, SharedFlow): Veri akışlarıyla çalışmak için primitive'ler. StateFlow "soğuk" akışını temsil eder ve mevcut durumu içerir, SharedFlow ise "sıcak" akış olup veri yayını yapar.

Kotlin hangi çoklu iş parçacığı öğelerini sağlar?