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 async задатак")
        }

        // 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") }
    }
}