Mobil ishlab chiqishda Thread — bu nima, turlari va oqimlarni boshqarish

Thread nima

Thread (bajarish oqimi) — operatsion tizim CPU yadrosida rejalashtirishi mumkin bo'lgan mustaqil ko'rsatmalar ketma-ketligi. Har bir jarayon (ilova) kamida bitta oqimni o'z ichiga oladi — Main Thread. Qo'shimcha oqimlar vazifalarni parallel bajarish uchun yaratiladi. Har bir oqim o'zining dasturiy stekiga (lokal o'zgaruvchilar bilan), buyruq hisoblagichiga (PC) va registrlarga ega. Heap xotirasi jarayonning barcha oqimlari uchun umumiy hisoblanadi.

Mobil operatsion tizimlarda oqimlar preemptive multitasking (majburiy ko'p vazifalilik) bilan rejalashtiriladi: operatsion tizim istalgan paytda oqim bajarilishini to'xtatib, boshqaruvni boshqasiga berishi mumkin (context switch). Kontekst almashinuvi qimmat operatsiya (1–10 mikrosekund), chunki CPU registrlarini saqlash/tiklash, TLB ni yangilash va keshlarni tozalash kerak. Aynan shuning uchun haddan tashqari ko'p oqim (yuzlab va minglab) ishlashni yomonlashtiradi — operatsion tizim bajarishdan ko'ra almashinishga ko'proq vaqt sarflaydi.

Oqim va jarayon — turli tushunchalar. Jarayon ajratilgan virtual xotiraga ega ilova nusxasi. Jarayon ichidagi oqim bu xotirani boshqa oqimlar bilan bo'lishadi. Android-da ilovaning har bir komponenti (Activity, Service, BroadcastReceiver) bitta jarayonda ishlaydi, lekin turli oqimlarda bajarilishi mumkin. iOS ilovasi ham GCD yoki Thread orqali qo'shimcha oqimlar yaratish imkoniyatiga ega bo'lgan bitta jarayondir.

Oqimning hayot aylanishi: holatlar va o'tishlar

Har bir oqim Java/Kotlin (Android) va NSThread (iOS) da besh holatdan o'tadi: New (yaratilgan), Runnable (bajarishga tayyor), Running (CPU-da bajarilmoqda), Blocked/Waiting (resurs yoki xabarnoma kutmoqda), Terminated (tugatilgan). Holatlar orasidagi o'tishlarni operatsion tizim rejalashtiruvchisi va sinxronizatsiya primitivlari boshqaradi. Dasturchi oqimning ustuvorligiga (Thread.setPriority()) va holatiga (sleep, join, interrupt) ta'sir qilishi mumkin.

Android-da oqim band monitor (synchronized)ni egallashga urinayotganda, Object.wait() yoki Thread.sleep() chaqirilganda Blocked holatiga o'tadi. iOS-da — NSCondition.wait(), pthread_cond_wait() yoki dispatch_semaphore_wait() chaqirilganda. Blocked holatida oqim CPU sarflamaydi, lekin xotira (stek) egallaydi. Oqim boshqa oqimdan uzilishi mumkin (interrupted), InterruptedException (Java) olib yoki isCancelled (Kotlin Coroutines) ni tekshirib.

Context Switch va uning narxi

Context switch (kontekst almashinuvi) — operatsion tizim joriy oqimning holatini (registrlar, PC, TLB) saqlab, boshqasining saqlangan holatini yuklaydigan operatsiya. Mobil tizimlarda (Linux + ART, iOS uchun XNU) context switch 1–10 mikrosekund davom etadi. Agar oqim vazifani 100 mikrosekundda bajarsa, context switch esa 5 da davom etsa, vaqtning 5 foizi behuda ketadi. Context switch-ni minimallashtirish uchun iOS work stealing bilan GCD-dan, Android esa fixedThreadCount hovuzlaridan foydalanadi.

Android-da Thread: Thread-dan Coroutines-gacha

Android past darajadagi java.lang.Thread-dan zamonaviy korutinlargacha evolyutsiyani bosib o'tdi. Abstraksiyaning har bir darajasi kamroq qo'shimcha xarajatlar bilan ko'proq imkoniyat beradi. Thread — asosiy sinf, lekin uni to'g'ridan-to'g'ri yaratish tavsiya etilmaydi: yangi oqim hovuz tomonidan boshqarilmaydi, uni kuzatish va bekor qilish qiyin. AsyncTask (API 30 dan deprecated) oldinga qadam edi, lekin xotira oqishidan va konfiguratsiyalarni noqulay qayta ishlashdan aziyat chekardi.

HandlerThread — xabarlar navbatini qayta ishlay oladigan Looper-li Thread maxsus kichik sinfi. Fon oqimida vazifalarni ketma-ket bajarish uchun ishlatiladi, masalan, ma'lumotlarni Room-ga yoki fayllarga yozish. HandlerThread start() chaqiruvi bilan yaratiladi, so'ngra Handler(handlerThread.looper) orqali xabarlar va Runnable yuborish mumkin. handlerThread.quit() chaqiruvi Looper-ni to'xtatadi va oqimni tugatadi.

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

class ThreadExample {

    // 1. Thread-ni to'g'ridan-to'g'ri yaratish (tavsiya etilmaydi)
    fun directThread() {
        val thread = Thread(Runnable {
            Thread.sleep(1000)
            print("To'g'ridan-to'g'ri oqim bajarildi")
        })
        thread.start()
    }

    // 2. Ketma-ket fon vazifalari uchun HandlerThread
    fun handlerThreadExample() {
        val handlerThread = HandlerThread("BackgroundQueue")
        handlerThread.start()

        val handler = Handler(handlerThread.looper)
        handler.post {
            // Fon oqimida ketma-ket bajarish
            Thread.sleep(500)
            print("HandlerThread: vazifa bajarildi")
        }

        // Oqimni to'xtatish (vazifalar tugaganda bajariladi)
        handlerThread.quitSafely()
    }

    // 3. Executors — oqimlar hovuzi
    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 — zamonaviy standart
    suspend fun coroutineExample() = kotlinx.coroutines.withContext(
        kotlinx.coroutines.Dispatchers.Default
    ) {
        print("Coroutine on thread: ${Thread.currentThread().getName()}")
    }
}

ThreadExample namunasi Android-da oqim abstraksiyasining barcha to'rt darajasini ko'rsatadi. Thread-ni to'g'ridan-to'g'ri yaratish — eng past darajali va samarasiz yondashuv. HandlerThread fonda ketma-ket vazifalar uchun foydali. Executors.newFixedThreadPool(4) 10 tagacha vazifani parallel bajarish uchun 4 oqimdan iborat hovuz yaratadi. Dispatchers.Default bilan Kotlin Coroutines — zamonaviy, samarali va xavfsiz usul.

HandlerThread: ketma-ket fon vazifalari

HandlerThread — ichki Looper va xabarlar navbatiga ega Thread ixtisoslashgan kichik sinfi. start() chaqiruvi bilan yaratiladi, so'ngra Handler(handlerThread.looper) orqali Runnable va xabarlar yuborilishi mumkin. HandlerThread vazifalarni qat'iy ketma-ket bajaradi — keyingi vazifa avvalgisi tugaguncha boshlanmaydi. Bu operatsiyalar tartibi muhim bo'lgan Room-ga yoki fayllarga ma'lumot yozishda qulay. quitSafely() chaqiruvi joriy vazifa tugagandan so'ng Looper-ni to'xtatadi.

import Foundation

class ThreadManager {

    // 1. Thread (past darajali)
    func createThread() {
        let thread = Thread {
            // Kod yangi oqimda bajariladi
            print("Current thread: \(Thread.current)")
        }
        thread.name = "com.app.worker"
        thread.qualityOfService = .utility
        thread.start()
    }

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

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

        // Yozishni sinxronlash uchun Barrier
        queue.async(flags: .barrier) {
            // Yozish paytida eksklyuziv kirish
            print("Barrier write: eksklyuziv kirish")
        }
    }

    // 3. Bog'liqlikli OperationQueue
    func operationQueueExample() {
        let queue = OperationQueue()
        queue.maxConcurrentOperationCount = 2
        queue.qualityOfService = .background

        let download = BlockOperation {
            print("Yuklab olinmoqda...")
        }
        let process = BlockOperation {
            print("Qayta ishlanmoqda...")
        }
        let save = BlockOperation {
            print("Saqlanmoqda...")
        }

        // Bog'liqliklar: download -> process -> save
        process.addDependency(download)
        save.addDependency(process)

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

// GCD barrier orqali 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-da sinxronizatsiya
import java.util.concurrent.atomic.AtomicInteger
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock

class Counter {

    // 1. AtomicInteger — oddiy hisoblagichlar uchun
    private val atomicCount = AtomicInteger(0)
    fun incrementAtomic() = atomicCount.incrementAndGet()

    // 2. synchronized — kritik bo'limlar uchun
    @Synchronized
    fun synchronizedOperation() {
        // Bir vaqtda faqat bitta oqim
        doWork()
    }

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

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

// Deadlock namunasi: A B-ni bloklaydi, B A-ni bloklaydi
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") }
    }
}