Mobil inkişafda Thread — bu nədir, növləri və axınların idarə edilməsi

Thread nədir

Thread (icra axını) — əməliyyat sisteminin CPU nüvəsində planlaşdıra bildiyi müstəqil təlimatlar ardıcıllığıdır. Hər bir proses (proqram) ən azı bir axın ehtiva edir — Main Thread. Əlavə axınlar tapşırıqların paralel icrası üçün yaradılır. Hər axının öz proqram yığını (lokal dəyişənlərlə), əmr sayğacı (PC) və registrləri var. Heap yaddaşı prosesin bütün axınları üçün ümumidir.

Mobil əməliyyat sistemlərində axınlar qabaqlayıcı multitasking (preemptive multitasking) ilə planlaşdırılır: ƏS axının icrasını istənilən an kəsib idarəetməni digərinə verə bilər (context switch). Kontekst keçidi bahalı əməliyyatdır (1–10 mikrosaniyə), çünki CPU registrlərinin saxlanması/bərpası, TLB-nin yenilənməsi və keşlərin təmizlənməsi tələb olunur. Məhz buna görə həddindən artıq çox axın (yüzlərlə və minlərlə) performansı pisləşdirir — ƏS icraya deyil, keçidə daha çox vaxt sərf edir.

Axın və proses — fərqli anlayışlardır. Proses ayrılmış virtual yaddaşa malik proqram nüsxəsidir. Proses daxilindəki axın bu yaddaşı digər axınlarla bölüşür. Android-də proqramın hər komponenti (Activity, Service, BroadcastReceiver) bir prosesdə işləyir, lakin müxtəlif axınlarda icra oluna bilər. iOS proqramı da GCD və ya Thread vasitəsilə əlavə axınlar yaratmaq imkanı olan bir prosesdir.

Axının həyat dövrü: vəziyyətlər və keçidlər

Hər axın Java/Kotlin (Android) və NSThread (iOS) üçün beş vəziyyətdən keçir: New (yaradılıb), Runnable (icraya hazırdır), Running (CPU-da icra olunur), Blocked/Waiting (resurs və ya bildiriş gözləyir), Terminated (tamamlanıb). Vəziyyətlər arası keçidlər ƏS planlayıcısı və sinxronizasiya primitivləri tərəfindən idarə olunur. Tərtibatçı axının prioritetinə (Thread.setPriority()) və vəziyyətinə (sleep, join, interrupt) təsir edə bilər.

Android-də axın məşğul monitoru (synchronized) ələ keçirməyə cəhd edəndə, Object.wait() və ya Thread.sleep() çağırarkən Blocked vəziyyətinə keçir. iOS-da — NSCondition.wait(), pthread_cond_wait() və ya dispatch_semaphore_wait() çağırarkən. Blocked vəziyyətində axın CPU sərf etmir, lakin yaddaş tutur (yığın). Axın digər axından kəsilə bilər (interrupted), InterruptedException (Java) alaraq və ya isCancelled (Kotlin Coroutines) yoxlayaraq.

Context Switch və onun qiyməti

Context switch (kontekst keçidi) — ƏS-nin cari axının vəziyyətini (registrlər, PC, TLB) saxladığı və digərinin saxlanmış vəziyyətini yüklədiyi əməliyyatdır. Mobil sistemlərdə (Linux + ART, iOS üçün XNU) context switch 1–10 mikrosaniyə çəkir. Əgər axın tapşırığı 100 mikrosaniyəyə icra edirsə, context switch isə 5 çəkir, o zaman vaxtın 5%-i boşa gedir. Context switch-i minimuma endirmək üçün iOS work stealing ilə GCD-dən, Android isə fixedThreadCount hovuzlarından istifadə edir.

Android-də Thread: Thread-dan Coroutines-a qədər

Android aşağı səviyyəli java.lang.Thread-dan müasir korutinlərə qədər təkamül keçib. Abstraksiyanın hər səviyyəsi daha az əlavə xərclə daha çox imkan verir. Thread — baza sinfidir, lakin onun birbaşa yaradılması tövsiyə olunmur: yeni axın hovuz tərəfindən idarə olunmur, onu izləmək və ləğv etmək çətindir. AsyncTask (API 30-dan deprecated) irəli addım idi, lakin yaddaş sızmasından və konfiqurasiyaların rahatsız emalından əziyyət çəkirdi.

HandlerThread — mesaj növbəsini emal edə bilən Looper-li Thread xüsusi alt sinfidir. Fondan axınında tapşırıqların ardıcıl icrası üçün istifadə olunur, məsələn, məlumatların Room-a və ya fayllara yazılması. HandlerThread start() çağırışı ilə yaradılır, sonra Handler(handlerThread.looper) vasitəsilə mesajlar və Runnable göndərilə bilər. handlerThread.quit() çağırışı Looper-i dayandırır və axını bitirir.

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

class ThreadExample {

    // 1. Thread-in birbaşa yaradılması (tövsiyə olunmur)
    fun directThread() {
        val thread = Thread(Runnable {
            Thread.sleep(1000)
            print("Birbaşa axın icra olundu")
        })
        thread.start()
    }

    // 2. Ardıcıl fon tapşırıqları üçün HandlerThread
    fun handlerThreadExample() {
        val handlerThread = HandlerThread("BackgroundQueue")
        handlerThread.start()

        val handler = Handler(handlerThread.looper)
        handler.post {
            // Fon axınında ardıcıl icra
            Thread.sleep(500)
            print("HandlerThread: tapşırıq icra olundu")
        }

        // Axının dayandırılması (tapşırıqlar bitdikdə icra olunur)
        handlerThread.quitSafely()
    }

    // 3. Executors — axın hovuzu
    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 — müasir standart
    suspend fun coroutineExample() = kotlinx.coroutines.withContext(
        kotlinx.coroutines.Dispatchers.Default
    ) {
        print("Coroutine on thread: ${Thread.currentThread().getName()}")
    }
}

ThreadExample nümunəsi Android-də axın abstraksiyasının bütün dörd səviyyəsini göstərir. Thread-in birbaşa yaradılması — ən aşağı səviyyəli və səmərəsiz yanaşmadır. HandlerThread fonda ardıcıl tapşırıqlar üçün faydalıdır. Executors.newFixedThreadPool(4) 10 tapşırığın paralel icrası üçün 4 axından ibarət hovuz yaradır. Dispatchers.Default ilə Kotlin Coroutines — müasir, effektiv və təhlükəsiz üsuldur.

HandlerThread: ardıcıl fon tapşırıqları

HandlerThread — daxili Looper və mesaj növbəsi olan xüsusi Thread alt sinfidir. start() çağırışı ilə yaradılır, sonra Handler(handlerThread.looper) vasitəsilə Runnable və mesajlar göndərilə bilər. HandlerThread tapşırıqları ciddi ardıcıllıqla icra edir — növbəti tapşırıq əvvəlki tamamlanana qədər başlamır. Bu, əməliyyat sırasının kritik olduğu Room-a və ya fayllara məlumat yazarkən rahatdır. quitSafely() çağırışı cari tapşırıq bitdikdən sonra Looper-i dayandırır.

import Foundation

class ThreadManager {

    // 1. Thread (aşağı səviyyəli)
    func createThread() {
        let thread = Thread {
            // Kod yeni axında icra olunur
            print("Current thread: \(Thread.current)")
        }
        thread.name = "com.app.worker"
        thread.qualityOfService = .utility
        thread.start()
    }

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

        queue.async {
            print("GCD async tapşırığı")
        }

        // Yazmanın sinxronizasiyası üçün Barrier
        queue.async(flags: .barrier) {
            // Yazma zamanı eksklüziv giriş
            print("Barrier write: eksklüziv giriş")
        }
    }

    // 3. Asılılıqlı OperationQueue
    func operationQueueExample() {
        let queue = OperationQueue()
        queue.maxConcurrentOperationCount = 2
        queue.qualityOfService = .background

        let download = BlockOperation {
            print("Yüklənir...")
        }
        let process = BlockOperation {
            print("Emal olunur...")
        }
        let save = BlockOperation {
            print("Yazılır...")
        }

        // Asılılıqlar: download -> process -> save
        process.addDependency(download)
        save.addDependency(process)

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

// GCD barrier vasitəsilə thread-safe kolleksiya
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-də sinxronizasiya
import java.util.concurrent.atomic.AtomicInteger
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock

class Counter {

    // 1. AtomicInteger — sadə sayğaclar üçün
    private val atomicCount = AtomicInteger(0)
    fun incrementAtomic() = atomicCount.incrementAndGet()

    // 2. synchronized — kritik bölmələr üçün
    @Synchronized
    fun synchronizedOperation() {
        // Bir anda yalnız bir axın
        doWork()
    }

    // 3. Korutinlərdən Mutex — suspend-safe
    private val mutex = Mutex()
    suspend fun mutexOperation() {
        mutex.withLock {
            // protected code — thread-safe
            doWork()
        }
    }

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

// Deadlock nümunəsi: A B-ni bloklayır, B A-nı bloklayır
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") }
    }
}