Mobil geliştirmede Thread — nedir, türleri ve iş parçacığı yönetimi

Thread Nedir

Thread (yürütme iş parçacığı) — işletim sisteminin bir CPU çekirdeğinde zamanlayabileceği bağımsız bir komut dizisidir. Her süreç (uygulama) en az bir iş parçacığı içerir — Main Thread. Görevlerin paralel yürütülmesi için ek iş parçacıkları oluşturulur. Her iş parçacığının kendi yazılım yığını (yerel değişkenlerle), program sayacı (PC) ve kayıtları vardır. Heap bellek, sürecin tüm iş parçacıkları tarafından paylaşılır.

Mobil işletim sistemlerinde, iş parçacıkları önleyici çoklu görev (preemptive multitasking) ile planlanır: İşletim sistemi, bir iş parçacığının yürütülmesini istediği zaman kesintiye uğratabilir ve kontrolü başka bir iş parçacığına devredebilir (context switch). Bağlam değiştirme, CPU kayıtlarının kaydedilmesi/geri yüklenmesi, TLB'nin güncellenmesi ve önbelleklerin temizlenmesini gerektirdiğinden maliyetli bir işlemdir (1-10 mikrosaniye). Bu nedenle aşırı sayıda iş parçacığı (yüzlerce ve binlerce) performansı düşürür — işletim sistemi yürütmeden çok bağlam değiştirmeye zaman harcar.

İş parçacığı ve süreç — farklı kavramlardır. Süreç, ayrılmış sanal belleğe sahip bir uygulama örneğidir. Bir süreç içindeki iş parçacığı, bu belleği diğer iş parçacıklarıyla paylaşır. Android'de, uygulamanın her bileşeni (Activity, Service, BroadcastReceiver) tek bir süreçte çalışır ancak farklı iş parçacıklarında yürütülebilir. Bir iOS uygulaması da GCD veya Thread aracılığıyla ek iş parçacıkları oluşturma olanağına sahip tek bir süreçtir.

İş Parçacığı Yaşam Döngüsü: Durumlar ve Geçişler

Her iş parçacığı Java/Kotlin (Android) ve NSThread (iOS) içinde beş durumdan geçer: New (oluşturuldu), Runnable (yürütmeye hazır), Running (CPU'da çalışıyor), Blocked/Waiting (kaynak veya bildirim bekliyor), Terminated (sonlandırıldı). Durumlar arasındaki geçişler, işletim sistemi zamanlayıcısı ve senkronizasyon temelleri tarafından yönetilir. Geliştirici, iş parçacığının önceliğini (Thread.setPriority()) ve durumunu (sleep, join, interrupt) etkileyebilir.

Android'de, bir iş parçacığı meşgul bir monitörü (synchronized) almaya çalıştığında, Object.wait() veya Thread.sleep() çağırdığında Blocked durumuna geçer. iOS'te — NSCondition.wait(), pthread_cond_wait() veya dispatch_semaphore_wait() çağrıldığında. Blocked durumunda, iş parçacığı CPU tüketmez ancak bellek (yığın) kaplar. Bir iş parçacığı başka bir iş parçacığından InterruptedException (Java) alarak veya isCancelled (Kotlin Coroutines) kontrol ederek kesintiye uğratılabilir (interrupted).

Context Switch ve Maliyeti

Context switch (bağlam değiştirme) — işletim sisteminin mevcut iş parçacığının durumunu (kayıtlar, PC, TLB) kaydettiği ve başka bir iş parçacığının kaydedilmiş durumunu yüklediği işlemdir. Mobil sistemlerde (Linux + ART, iOS için XNU), context switch 1-10 mikrosaniye sürer. Bir iş parçacığı 100 mikrosaniyelik bir görevi yürütüyorsa ve context switch 5 mikrosaniye sürüyorsa, zamanın %5'i boşa harcanır. Context switch'leri en aza indirmek için iOS work stealing ile GCD'yi, Android ise fixedThreadCount ile havuzları kullanır.

Android'de Thread: Thread'den Coroutines'e

Android, düşük seviyeli java.lang.Thread'den modern coroutine'lere evrilmiştir. Her soyutlama seviyesi, daha az ek yük ile daha fazla yetenek sunar. Thread temel sınıftır ancak doğrudan oluşturulması önerilmez: yeni bir iş parçacığı havuz tarafından yönetilmez, izlenmesi ve iptal edilmesi zordur. AsyncTask (API 30'dan itibaren kullanımdan kaldırıldı) bir adım ileriydi ancak bellek sızıntıları ve yapılandırmaların kullanışsız yönetiminden muzdaripti.

HandlerThread, Looper ile mesaj kuyruğunu işleyebilen özel bir Thread alt sınıfıdır. Arka plan iş parçacığında sıralı görevlerin yürütülmesi için kullanılır, örneğin Room'a veya dosyalara veri yazmak. HandlerThread, start() çağrılarak oluşturulur, ardından Handler(handlerThread.looper) aracılığıyla mesajlar ve Runnable gönderilebilir. handlerThread.quit() çağrısı Looper'ı durdurur ve iş parçacığını sonlandırır.

// Android: Thread, HandlerThread ve Executors
import android.os.Handler
import android.os.HandlerThread
import java.util.concurrent.Executors

class ThreadExample {

    // 1. Doğrudan Thread oluşturma (önerilmez)
    fun directThread() {
        val thread = Thread(Runnable {
            Thread.sleep(1000)
            print("Direct thread executed")
        })
        thread.start()
    }

    // 2. Sıralı arka plan görevleri için HandlerThread
    fun handlerThreadExample() {
        val handlerThread = HandlerThread("BackgroundQueue")
        handlerThread.start()

        val handler = Handler(handlerThread.looper)
        handler.post {
            // Arka plan iş parçacığında sıralı yürütme
            Thread.sleep(500)
            print("HandlerThread: görev tamamlandı")
        }

        // İş parçacığını durdurma (görevler bittiğinde çalışır)
        handlerThread.quitSafely()
    }

    // 3. Executors — iş parçacığı havuzu
    fun executorExample() {
        val executor = Executors.newFixedThreadPool(4)
        for (i in 1..10) {
            executor.execute {
                print("Task $i on thread ${Thread.currentThread().getName()}")
            }
        }
        executor.shutdown()
    }

    // 4. Kotlin Coroutines — modern standart
    suspend fun coroutineExample() = kotlinx.coroutines.withContext(
        kotlinx.coroutines.Dispatchers.Default
    ) {
        print("Coroutine on thread: ${Thread.currentThread().getName()}")
    }
}

ThreadExample, Android'deki dört iş parçacığı soyutlama seviyesinin tümünü gösterir. Doğrudan Thread oluşturmak en düşük seviyeli ve en verimsiz yaklaşımdır. HandlerThread, arka planda sıralı görevler için kullanışlıdır. Executors.newFixedThreadPool(4), 10'a kadar görevin paralel yürütülmesi için 4 iş parçacıklı bir havuz oluşturur. Kotlin Coroutines ve Dispatchers.Default — modern, verimli ve güvenli bir yöntemdir.

HandlerThread: Sıralı Arka Plan Görevleri

HandlerThread — yerleşik Looper ve mesaj kuyruğuna sahip özelleştirilmiş bir Thread alt sınıfıdır. start() çağrılarak oluşturulur, ardından Handler(handlerThread.looper) aracılığıyla Runnable ve mesajlar gönderilebilir. HandlerThread görevleri kesinlikle sırayla yürütür — sonraki görev, önceki tamamlanana kadar başlamaz. Bu, işlem sırasının kritik olduğu Room veya dosyalara veri yazmak için kullanışlıdır. quitSafely() çağrısı, mevcut görev tamamlandıktan sonra Looper'ı durdurur.

import Foundation

class ThreadManager {

    // 1. Thread (düşük seviye)
    func createThread() {
        let thread = Thread {
            // Kod yeni bir iş parçacığında yürütülür
            print("Current thread: \(Thread.current)")
        }
        thread.name = "com.app.worker"
        thread.qualityOfService = .utility
        thread.start()
    }

    // 2. GCD — DispatchQueue
    func gcdExample() {
        // Paralel kuyruk
        let queue = DispatchQueue(label: "com.app.concurrent",
                                 qos: .utility,
                                 attributes: .concurrent)

        queue.async {
            print("GCD async task")
        }

        // Yazma senkronizasyonu için Barrier
        queue.async(flags: .barrier) {
            // Yazma sırasında özel erişim
            print("Barrier write: exclusive access")
        }
    }

    // 3. Bağımlılıklı OperationQueue
    func operationQueueExample() {
        let queue = OperationQueue()
        queue.maxConcurrentOperationCount = 2
        queue.qualityOfService = .background

        let download = BlockOperation {
            print("Downloading...")
        }
        let process = BlockOperation {
            print("Processing...")
        }
        let save = BlockOperation {
            print("Saving...")
        }

        // Bağımlılıklar: download -> process -> save
        process.addDependency(download)
        save.addDependency(process)

        queue.addOperations([download, process, save], waitUntilFinished: false)
    }
}

// GCD barrier ile thread-safe koleksiyon
class ThreadSafeArray<T> {
    private var array: [T] = []
    private let queue = DispatchQueue(label: "com.app.concurrent",
                                       attributes: .concurrent)

    var count: Int {
        return queue.sync { array.count } // concurrent read
    }

    func append(_ element: T) {
        queue.async(flags: .barrier) { // exclusive write
            self.array.append(element)
        }
    }
}

// Android/Kotlin'de senkronizasyon
import java.util.concurrent.atomic.AtomicInteger
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock

class Counter {

    // 1. AtomicInteger — basit sayaçlar için
    private val atomicCount = AtomicInteger(0)
    fun incrementAtomic() = atomicCount.incrementAndGet()

    // 2. synchronized — kritik bölümler için
    @Synchronized
    fun synchronizedOperation() {
        // Her seferinde yalnızca bir iş parçacığı
        doWork()
    }

    // 3. Coroutine'lerden Mutex — suspend-safe
    private val mutex = Mutex()
    suspend fun mutexOperation() {
        mutex.withLock {
            // protected code — thread-safe
            doWork()
        }
    }

    private fun doWork() { /* critical section */ }
}

// Deadlock örneği: A, B'yi kilitler, B, A'yı kilitler
class DeadlockExample {
    private val lockA = Any()
    private val lockB = Any()

    fun methodA() = synchronized(lockA) {
        Thread.sleep(100)
        synchronized(lockB) { print("OK") }
    }

    fun methodB() = synchronized(lockB) {
        Thread.sleep(100)
        synchronized(lockA) { print("OK") }
    }
}