Thread v mobilním vývoji — co to je, druhy a správa vláken

Co je Thread

Thread (vlákno provádění) — nezávislá posloupnost instrukcí, kterou může operační systém naplánovat na jádro CPU. Každý proces (aplikace) obsahuje alespoň jedno vlákno — Main Thread. Další vlákna se vytvářejí pro paralelní provádění úloh. Každé vlákno má vlastní programový zásobník (s lokálními proměnnými), čítač instrukcí (PC) a registry. Paměť haldy (heap) je společná pro všechna vlákna procesu.

V mobilních operačních systémech jsou vlákna plánována preemptivním multitaskingem: operační systém může provádění vlákna kdykoli přerušit a předat řízení jinému (context switch). Přepnutí kontextu je nákladná operace (1–10 mikrosekund), protože vyžaduje uložení/obnovení registrů CPU, aktualizaci TLB a vyčištění mezipamětí. Právě proto nadměrný počet vláken (stovky a tisíce) zhoršuje výkon — operační systém tráví více času přepínáním než prováděním.

Vlákno a proces jsou různé pojmy. Proces je instance aplikace s vyhrazenou virtuální pamětí. Vlákno uvnitř procesu sdílí tuto paměť s ostatními vlákny. V Androidu každá komponenta aplikace (Activity, Service, BroadcastReceiver) pracuje v jednom procesu, ale může běžet v různých vláknech. Aplikace iOS je také jedním procesem s možností vytvářet další vlákna přes GCD nebo Thread.

Životní cyklus vlákna: stavy a přechody

Každé vlákno v Java/Kotlin (Android) a NSThread (iOS) prochází pěti stavy: New (vytvořeno), Runnable (připraveno k provádění), Running (běží na CPU), Blocked/Waiting (čeká na zdroj nebo oznámení), Terminated (ukončeno). Přechody mezi stavy řídí plánovač operačního systému a synchronizační primitiva. Vývojář může ovlivnit prioritu vlákna (Thread.setPriority()) a jeho stav (sleep, join, interrupt).

V Androidu přechází vlákno do stavu Blocked při pokusu o získání obsazeného monitoru (synchronized), při volání Object.wait() nebo Thread.sleep(). V iOS — při volání NSCondition.wait(), pthread_cond_wait() nebo dispatch_semaphore_wait(). Ve stavu Blocked vlákno nespotřebovává CPU, ale zabírá paměť (zásobník). Vlákno může být přerušeno (interrupted) z jiného vlákna, obdrží InterruptedException (Java) nebo kontrolou isCancelled (Kotlin Coroutines).

Context Switch a jeho cena

Context switch (přepnutí kontextu) — operace, při které operační systém uloží stav aktuálního vlákna (registry, PC, TLB) a načte uložený stav jiného. V mobilních systémech (Linux + ART, XNU pro iOS) trvá context switch 1–10 mikrosekund. Pokud vlákno provádí úlohu za 100 mikrosekund a context switch trvá 5, ztrácí se 5 % času. Pro minimalizaci context switch používá iOS GCD s work stealing, Android — fondy s fixedThreadCount.

Thread v Androidu: od Threadu po Coroutines

Android prošel evolucí od nízkoúrovňového java.lang.Thread po moderní korutiny. Každá úroveň abstrakce dává více možností s menší režií. Thread je základní třída, ale jeho přímé vytváření se nedoporučuje: nové vlákno není spravováno fondem, je obtížné ho sledovat a rušit. AsyncTask (deprecated od API 30) byl krokem vpřed, ale trpěl úniky paměti a nepohodlným zpracováním konfigurací.

HandlerThread — speciální podtřída Thread s Looper, která může zpracovávat frontu zpráv. Používá se pro sekvenční provádění úloh na vlákně na pozadí, například zápis dat do Room nebo souborů. HandlerThread se vytváří voláním start(), poté lze přes Handler(handlerThread.looper) odesílat zprávy a Runnable. Volání handlerThread.quit() zastaví Looper a ukončí vlákno.

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

class ThreadExample {

    // 1. Přímé vytvoření Thread (nedoporučuje se)
    fun directThread() {
        val thread = Thread(Runnable {
            Thread.sleep(1000)
            print("Přímé vlákno vykonáno")
        })
        thread.start()
    }

    // 2. HandlerThread pro sekvenční úlohy na pozadí
    fun handlerThreadExample() {
        val handlerThread = HandlerThread("BackgroundQueue")
        handlerThread.start()

        val handler = Handler(handlerThread.looper)
        handler.post {
            // Sekvenční provádění na vlákně na pozadí
            Thread.sleep(500)
            print("HandlerThread: úloha dokončena")
        }

        // Zastavení vlákna (spustí se po dokončení úloh)
        handlerThread.quitSafely()
    }

    // 3. Executors — fond vláken
    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 — moderní standard
    suspend fun coroutineExample() = kotlinx.coroutines.withContext(
        kotlinx.coroutines.Dispatchers.Default
    ) {
        print("Coroutine on thread: ${Thread.currentThread().getName()}")
    }
}

Příklad ThreadExample ukazuje všechny čtyři úrovně abstrakce vláken v Androidu. Přímé vytvoření Thread je nejnízkoúrovňovější a nejméně efektivní přístup. HandlerThread je užitečný pro sekvenční úlohy na pozadí. Executors.newFixedThreadPool(4) vytváří fond 4 vláken pro paralelní provádění až 10 úloh. Kotlin Coroutines s Dispatchers.Default — moderní, efektivní a bezpečný způsob.

HandlerThread: sekvenční úlohy na pozadí

HandlerThread — specializovaná podtřída Thread s vestavěným Looper a frontou zpráv. Vytváří se voláním start(), poté lze přes Handler(handlerThread.looper) odesílat Runnable a zprávy. HandlerThread provádí úlohy přísně sekvenčně — další úloha nezačne, dokud se nedokončí předchozí. To je vhodné pro zápis dat do Room nebo souborů, kde je pořadí operací kritické. Volání quitSafely() zastaví Looper po dokončení aktuální úlohy.

import Foundation

class ThreadManager {

    // 1. Thread (nízkoúrovňový)
    func createThread() {
        let thread = Thread {
            // Kód běží na novém vlákně
            print("Current thread: \(Thread.current)")
        }
        thread.name = "com.app.worker"
        thread.qualityOfService = .utility
        thread.start()
    }

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

        queue.async {
            print("Asynchronní úloha GCD")
        }

        // Barrier pro synchronizaci zápisu
        queue.async(flags: .barrier) {
            // Exkluzivní přístup během zápisu
            print("Barrier write: exkluzivní přístup")
        }
    }

    // 3. OperationQueue se závislostmi
    func operationQueueExample() {
        let queue = OperationQueue()
        queue.maxConcurrentOperationCount = 2
        queue.qualityOfService = .background

        let download = BlockOperation {
            print("Stahování...")
        }
        let process = BlockOperation {
            print("Zpracování...")
        }
        let save = BlockOperation {
            print("Ukládání...")
        }

        // Závislosti: download -> process -> save
        process.addDependency(download)
        save.addDependency(process)

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

// Thread-safe kolekce přes 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)
        }
    }
}

// Synchronizace v Android/Kotlin
import java.util.concurrent.atomic.AtomicInteger
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock

class Counter {

    // 1. AtomicInteger — pro jednoduchá počítadla
    private val atomicCount = AtomicInteger(0)
    fun incrementAtomic() = atomicCount.incrementAndGet()

    // 2. synchronized — pro kritické sekce
    @Synchronized
    fun synchronizedOperation() {
        // Vždy jen jedno vlákno
        doWork()
    }

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

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

// Příklad deadlock: A blokuje B, B blokuje 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") }
    }
}