Thread în dezvoltarea mobilă — ce este, tipuri și gestionarea firelor de execuție

Ce este Thread

Thread (fir de execuție) — o secvență independentă de instrucțiuni pe care sistemul de operare o poate planifica pe nucleul CPU. Fiecare proces (aplicație) conține cel puțin un fir — Main Thread. Firele suplimentare sunt create pentru execuția paralelă a sarcinilor. Fiecare fir are propriul stiv de program (cu variabile locale), contorul de program (PC) și registre. Memoria heap este partajată de toate firele procesului.

În sistemele de operare mobile, firele sunt planificate prin multitasking preemptiv (preemptive multitasking): sistemul de operare poate întrerupe execuția unui fir în orice moment și poate transmite controlul altuia (context switch). Comutarea de context este o operațiune costisitoare (1–10 microsecunde), deoarece necesită salvarea/restaurarea registrelor CPU, actualizarea TLB și golirea cache-urilor. Tocmai de aceea un număr excesiv de fire (sute și mii) degradează performanța — sistemul de operare petrece mai mult timp comutând decât executând.

Fir și proces sunt concepte diferite. Procesul este o instanță a aplicației cu memorie virtuală dedicată. Firul din interiorul procesului împarte această memorie cu alte fire. În Android, fiecare component al aplicației (Activity, Service, BroadcastReceiver) funcționează într-un singur proces, dar poate fi executat în fire diferite. Aplicația iOS este, de asemenea, un singur proces cu posibilitatea de a crea fire suplimentare prin GCD sau Thread.

Ciclul de viață al firului: stări și tranziții

Fiecare fir în Java/Kotlin (Android) și NSThread (iOS) trece prin cinci stări: New (creat), Runnable (gata de execuție), Running (se execută pe CPU), Blocked/Waiting (așteaptă o resursă sau o notificare), Terminated (terminat). Tranzițiile între stări sunt gestionate de planificatorul sistemului de operare și de primitivele de sincronizare. Dezvoltatorul poate influența prioritatea firului (Thread.setPriority()) și starea acestuia (sleep, join, interrupt).

În Android, firul trece în starea Blocked la încercarea de a captura un monitor ocupat (synchronized), la apelul Object.wait() sau Thread.sleep(). În iOS — la apelul NSCondition.wait(), pthread_cond_wait() sau dispatch_semaphore_wait(). În starea Blocked, firul nu consumă CPU, dar ocupă memorie (stiv). Firul poate fi întrerupt (interrupted) dintr-un alt fir, primind InterruptedException (Java) sau verificând isCancelled (Kotlin Coroutines).

Context Switch și costul său

Context switch (comutarea de context) — operațiunea în care sistemul de operare salvează starea firului curent (registre, PC, TLB) și încarcă starea salvată a altuia. În sistemele mobile (Linux + ART, XNU pentru iOS), context switch durează 1–10 microsecunde. Dacă firul execută o sarcină în 100 de microsecunde, iar context switch durează 5, atunci 5% din timp este irosit. Pentru a minimiza context switch, iOS folosește GCD cu work stealing, iar Android — pool-uri cu fixedThreadCount.

Thread în Android: de la Thread la Coroutines

Android a evoluat de la java.lang.Thread de nivel scăzut la corutinele moderne. Fiecare nivel de abstractizare oferă mai multe posibilități cu costuri suplimentare mai mici. Thread este clasa de bază, dar crearea sa directă nu este recomandată: firul nou nu este gestionat de un pool, este greu de monitorizat și anulat. AsyncTask (deprecated din API 30) a fost un pas înainte, dar suferea de scurgeri de memorie și de gestionarea incomodă a configurațiilor.

HandlerThread — o subclasă specială a Thread cu Looper, care poate procesa o coadă de mesaje. Este folosit pentru execuția secvențială a sarcinilor pe un fir de fundal, de exemplu scrierea datelor în Room sau în fișiere. HandlerThread este creat prin apelul start(), după care prin Handler(handlerThread.looper) pot fi trimise mesaje și Runnable. Apelul handlerThread.quit() oprește Looper și termină firul.

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

class ThreadExample {

    // 1. Crearea directă a Thread (nu este recomandată)
    fun directThread() {
        val thread = Thread(Runnable {
            Thread.sleep(1000)
            print("Firul direct executat")
        })
        thread.start()
    }

    // 2. HandlerThread pentru sarcini secvențiale de fundal
    fun handlerThreadExample() {
        val handlerThread = HandlerThread("BackgroundQueue")
        handlerThread.start()

        val handler = Handler(handlerThread.looper)
        handler.post {
            // Execuție secvențială pe firul de fundal
            Thread.sleep(500)
            print("HandlerThread: sarcina executată")
        }

        // Oprirea firului (se execută când sarcinile sunt terminate)
        handlerThread.quitSafely()
    }

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

Exemplul ThreadExample arată toate cele patru niveluri de abstractizare a firelor în Android. Crearea directă a Thread este cea mai de nivel scăzut și ineficientă abordare. HandlerThread este util pentru sarcini secvențiale în fundal. Executors.newFixedThreadPool(4) creează un pool de 4 fire pentru execuția paralelă a până la 10 sarcini. Kotlin Coroutines cu Dispatchers.Default — o metodă modernă, eficientă și sigură.

HandlerThread: sarcini secvențiale de fundal

HandlerThread — o subclasă specializată a Thread cu Looper încorporat și coadă de mesaje. Este creat prin apelul start(), după care prin Handler(handlerThread.looper) pot fi trimise Runnable și mesaje. HandlerThread execută sarcinile strict secvențial — sarcina următoare nu începe până la finalizarea celei anterioare. Acest lucru este convenabil pentru scrierea datelor în Room sau în fișiere, unde ordinea operațiunilor este critică. Apelul quitSafely() oprește Looper după finalizarea sarcinii curente.

import Foundation

class ThreadManager {

    // 1. Thread (de nivel scăzut)
    func createThread() {
        let thread = Thread {
            // Codul se execută pe un fir nou
            print("Current thread: \(Thread.current)")
        }
        thread.name = "com.app.worker"
        thread.qualityOfService = .utility
        thread.start()
    }

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

        queue.async {
            print("Sarcină asincronă GCD")
        }

        // Barrier pentru sincronizarea scrierii
        queue.async(flags: .barrier) {
            // Acces exclusiv în timpul scrierii
            print("Barrier write: acces exclusiv")
        }
    }

    // 3. OperationQueue cu dependențe
    func operationQueueExample() {
        let queue = OperationQueue()
        queue.maxConcurrentOperationCount = 2
        queue.qualityOfService = .background

        let download = BlockOperation {
            print("Se descarcă...")
        }
        let process = BlockOperation {
            print("Se procesează...")
        }
        let save = BlockOperation {
            print("Se salvează...")
        }

        // Dependențe: download -> process -> save
        process.addDependency(download)
        save.addDependency(process)

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

// Colecție thread-safe prin 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)
        }
    }
}

// Sincronizare în Android/Kotlin
import java.util.concurrent.atomic.AtomicInteger
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock

class Counter {

    // 1. AtomicInteger — pentru contoare simple
    private val atomicCount = AtomicInteger(0)
    fun incrementAtomic() = atomicCount.incrementAndGet()

    // 2. synchronized — pentru secțiuni critice
    @Synchronized
    fun synchronizedOperation() {
        // Doar un fir pe rând
        doWork()
    }

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

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

// Exemplu deadlock: A blochează B, B blochează 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") }
    }
}