Kotlin'de çoklu iş parçacığını nasıl uygularsınız…

Kotlin'de çoklu iş parçacığı birkaç şekilde gerçekleştirilebilir:

Standart Java İşlemleri (Threads):

// Runnable arayüzünü uygula
class MyRunnable : Runnable {
    override fun run() {
        // Ayrı bir iş parçacığında çalışacak kod
        println("İş parçacığından merhaba: ${Thread.currentThread().name}")
    }
}

fun main() {
    // Runnable örneği oluştur
    val runnable = MyRunnable()
    // Runnable ile Thread nesnesi oluştur
    val thread = Thread(runnable)
    // İş parçacığını başlat
    thread.start()
}

Veya lambda ifadesi kullanarak:

fun main() {
    val thread = Thread {
        // Ayrı bir iş parçacığında çalışacak kod
        println("İş parçacığından merhaba: ${Thread.currentThread().name}")
    }
    thread.start()
}

Kotlin Coroutines (Koruletler): Bu, Kotlin'de önerilen ve daha modern bir yaklaşımdır, hafif çoklu iş parçacığı sağlar.

import kotlinx.coroutines.*

fun main() = runBlocking {
    // Yeni bir coroutine oluştur
    launch {
        delay(1000L) // Bloke etmeyen gecikme
        println("Koruletlerden merhaba")
    }
    // Ana iş parçacığı çalışmaya devam eder
    println("Ana iş parçacığından merhaba")
    // runBlocking, iç içe korutinaların tamamlanmasını bekler
}

Farklı korutina yapıcı örnekleri:

launch: Yeni bir korutina başlatır, dönüş değeri yoktur.

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        println("Bu korutina sadece bir işlem gerçekleştirir")
    }
}

async: Yeni bir korutina başlatır ve Deferred kullanarak sonuç döner.

import kotlinx.coroutines.*

fun main() = runBlocking {
    val deferredResult = async {
        delay(1000L)
        "Korutina sonucu"
    }
    val result = deferredResult.await() // Sonucu bekle
    println(result)
}

RxKotlin/RxJava: Reaktif programlama, asenkron işlemler ve çoklu iş parçacığı ile çalışmayı da sağlar, planlayıcılar (Schedulers) kullanılır.

import io.reactivex.rxjava3.core.Observable
import io.reactivex.rxjava3.schedulers.Schedulers

fun main() {
    Observable.just("Asenkron öğe")
        .subscribeOn(Schedulers.io()) // I/O iş parçacığında abone ol
        .observeOn(Schedulers.computation()) // Sonuçları hesaplama iş parçacığında gözle
        .subscribe { item ->
            println("Alındı: $item ${Thread.currentThread().name} iş parçacığında")
        }

    Thread.sleep(2000) // Asenkron işlemlerin tamamlanmasını bekle
}

Yöntem seçimi, belirli göreve bağlıdır. Kotlin'deki modern uygulamaların çoğu için, hafiflikleri, kullanım kolaylıkları ve dilde yerleşik destekleri nedeniyle korutinalar tercih edilir. Java iş parçacıkları daha düşük seviyeli kontrol için uygun olabilir, reaktif kütüphaneler ise veri akışlarıyla çalışmak için kullanılır.

Kotlin'de çoklu iş parçacığını nasıl uygularsınız?