Thread в мобилната разработка — какво е, видове и управление на нишки

Какво е Thread

Thread (нишка на изпълнение) — независима последователност от инструкции, която операционната система може да планира върху ядро на CPU. Всеки процес (приложение) съдържа поне една нишка — Main Thread. Допълнителни нишки се създават за паралелно изпълнение на задачи. Всяка нишка има собствен програмен стек (с локални променливи), брояч на команди (PC) и регистри. Паметта на купчината (heap) е обща за всички нишки на процеса.

В мобилните операционни системи нишките се планират чрез превантивна многозадачност (preemptive multitasking): операционната система може да прекъсне изпълнението на нишка във всеки момент и да предаде контрола на друга (context switch). Смяната на контекста е скъпа операция (1–10 микросекунди), защото изисква запазване/възстановяване на CPU регистрите, актуализиране на TLB и изчистване на кешовете. Точно затова прекомерният брой нишки (стотици и хиляди) влошава производителността — операционната система харчи повече време за превключване, отколкото за изпълнение.

Нишка и процес са различни понятия. Процесът е инстанция на приложението с отделена виртуална памет. Нишката вътре в процеса споделя тази памет с другите нишки. В Android всеки компонент на приложението (Activity, Service, BroadcastReceiver) работи в един процес, но може да се изпълнява в различни нишки. Приложението iOS също е един процес с възможност за създаване на допълнителни нишки чрез GCD или Thread.

Жизненият цикъл на нишката: състояния и преходи

Всяка нишка в Java/Kotlin (Android) и NSThread (iOS) преминава през пет състояния: New (създадена), Runnable (готова за изпълнение), Running (изпълнява се на CPU), Blocked/Waiting (чака ресурс или известие), Terminated (завършена). Преходите между състоянията се управляват от планировчика на операционната система и синхронизиращите примитиви. Разработчикът може да влияе на приоритета на нишката (Thread.setPriority()) и на нейното състояние (sleep, join, interrupt).

В Android нишката преминава в състояние Blocked при опит за завземане на зает монитор (synchronized), при извикване на Object.wait() или Thread.sleep(). В iOS — при извикване на NSCondition.wait(), pthread_cond_wait() или dispatch_semaphore_wait(). В състояние Blocked нишката не консумира CPU, но заема памет (стек). Нишката може да бъде прекъсната (interrupted) от друга нишка, получавайки InterruptedException (Java) или проверявайки isCancelled (Kotlin Coroutines).

Context Switch и неговата цена

Context switch (смяна на контекста) — операцията, при която операционната система запазва състоянието на текущата нишка (регистри, PC, TLB) и зарежда запазеното състояние на друга. В мобилните системи (Linux + ART, XNU за iOS) context switch продължава 1–10 микросекунди. Ако нишката изпълнява задача за 100 микросекунди, а context switch трае 5, тогава 5% от времето се губи. За да се минимизира context switch, iOS използва GCD с work stealing, а Android — пулове с fixedThreadCount.

Thread в Android: от Thread до Coroutines

Android еволюира от нискорисковото java.lang.Thread до съвременните корутини. Всяко ниво на абстракция дава повече възможности с по-малки допълнителни разходи. Thread е базовият клас, но директното му създаване не се препоръчва: новата нишка не се управлява от пул, трудно е да се наблюдава и отменя. AsyncTask (deprecated от API 30) беше стъпка напред, но страдаше от изтичане на памет и неудобна обработка на конфигурации.

HandlerThread — специален подклас на Thread с Looper, който може да обработва опашка от съобщения. Използва се за последователно изпълнение на задачи във фонова нишка, например запис на данни в Room или файлове. HandlerThread се създава с извикване на start(), след което чрез Handler(handlerThread.looper) могат да се изпращат съобщения и Runnable. Извикването на handlerThread.quit() спира Looper и завършва нишката.

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

class ThreadExample {

    // 1. Директно създаване на Thread (не се препоръчва)
    fun directThread() {
        val thread = Thread(Runnable {
            Thread.sleep(1000)
            print("Директна нишка е изпълнена")
        })
        thread.start()
    }

    // 2. HandlerThread за последователни фонови задачи
    fun handlerThreadExample() {
        val handlerThread = HandlerThread("BackgroundQueue")
        handlerThread.start()

        val handler = Handler(handlerThread.looper)
        handler.post {
            // Последователно изпълнение във фонова нишка
            Thread.sleep(500)
            print("HandlerThread: задачата е изпълнена")
        }

        // Спиране на нишката (изпълнява се, когато задачите приключат)
        handlerThread.quitSafely()
    }

    // 3. Executors — пул от нишки
    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 — съвременен стандарт
    suspend fun coroutineExample() = kotlinx.coroutines.withContext(
        kotlinx.coroutines.Dispatchers.Default
    ) {
        print("Coroutine on thread: ${Thread.currentThread().getName()}")
    }
}

Примерът ThreadExample показва всичките четири нива на абстракция на нишките в Android. Директното създаване на Thread е най-нискорисковото и най-неефективното решение. HandlerThread е полезен за последователни задачи на фона. Executors.newFixedThreadPool(4) създава пул от 4 нишки за паралелно изпълнение на до 10 задачи. Kotlin Coroutines с Dispatchers.Default — съвременен, ефективен и безопасен начин.

HandlerThread: последователни фонови задачи

HandlerThread — специализиран подклас на Thread с вграден Looper и опашка от съобщения. Създава се с извикване на start(), след което чрез Handler(handlerThread.looper) могат да се изпращат Runnable и съобщения. HandlerThread изпълнява задачите строго последователно — следващата задача не започва, докато не приключи предишната. Това е удобно при запис на данни в Room или файлове, където редът на операциите е критичен. Извикването на quitSafely() спира Looper след приключване на текущата задача.

import Foundation

class ThreadManager {

    // 1. Thread (ниско ниво)
    func createThread() {
        let thread = Thread {
            // Кодът се изпълнява в нова нишка
            print("Current thread: \(Thread.current)")
        }
        thread.name = "com.app.worker"
        thread.qualityOfService = .utility
        thread.start()
    }

    // 2. GCD — DispatchQueue
    func gcdExample() {
        // Паралелна опашка
        let queue = DispatchQueue(label: "com.app.concurrent",
                                 qos: .utility,
                                 attributes: .concurrent)

        queue.async {
            print("Асинхронна задача GCD")
        }

        // Barrier за синхронизиране на записа
        queue.async(flags: .barrier) {
            // Ексклузивен достъп по време на запис
            print("Barrier write: ексклузивен достъп")
        }
    }

    // 3. OperationQueue със зависимости
    func operationQueueExample() {
        let queue = OperationQueue()
        queue.maxConcurrentOperationCount = 2
        queue.qualityOfService = .background

        let download = BlockOperation {
            print("Изтегляне...")
        }
        let process = BlockOperation {
            print("Обработка...")
        }
        let save = BlockOperation {
            print("Записване...")
        }

        // Зависимости: download -> process -> save
        process.addDependency(download)
        save.addDependency(process)

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

// Thread-safe колекция чрез GCD barrier
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
import java.util.concurrent.atomic.AtomicInteger
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock

class Counter {

    // 1. AtomicInteger — за прости броячи
    private val atomicCount = AtomicInteger(0)
    fun incrementAtomic() = atomicCount.incrementAndGet()

    // 2. synchronized — за критични секции
    @Synchronized
    fun synchronizedOperation() {
        // Само една нишка наведнъж
        doWork()
    }

    // 3. Mutex от корутини — suspend-safe
    private val mutex = Mutex()
    suspend fun mutexOperation() {
        mutex.withLock {
            // protected code — безопасно за нишки
            doWork()
        }
    }

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

// Пример за deadlock: A блокира B, B блокира A
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") }
    }
}