Thread a mobilfejlesztésben — mi ez, típusai és a szálak kezelése

Mi az a Thread

Thread (végrehajtási szál) — független utasítássorozat, amelyet az operációs rendszer a CPU magjára ütemezhet. Minden folyamat (alkalmazás) legalább egy szálat tartalmaz — a Main Thread-et. A további szálak a feladatok párhuzamos végrehajtására jönnek létre. Minden szálnak saját programverme (lokális változókkal), programszámlálója (PC) és regiszterei vannak. A heap memória közös a folyamat összes szálában.

A mobil operációs rendszerekben a szálakat preemptív multitaskinggal ütemezik: az operációs rendszer bármikor megszakíthatja egy szál végrehajtását, és átadhatja a vezérlést egy másiknak (context switch). A kontextusváltás költséges művelet (1–10 mikroszekundum), mert a CPU regiszterek mentését/visszaállítását, a TLB frissítését és a gyorsítótárak kiürítését igényli. Éppen ezért a túlzott számú szál (több száz és több ezer) rontja a teljesítményt — az operációs rendszer több időt tölt váltással, mint végrehajtással.

Szál és folyamat különböző fogalmak. A folyamat az alkalmazás egy példánya elkülönített virtuális memóriával. A folyamaton belüli szál ezt a memóriát megosztja a többi szállal. Androidon az alkalmazás minden komponense (Activity, Service, BroadcastReceiver) egy folyamatban működik, de különböző szálakon futhat. Az iOS-alkalmazás szintén egyetlen folyamat, amely lehetőséget ad további szálak létrehozására a GCD vagy a Thread révén.

A szál életciklusa: állapotok és átmenetek

Minden szál a Java/Kotlin (Android) és az NSThread (iOS) esetében öt állapoton megy keresztül: New (létrehozva), Runnable (végrehajtásra kész), Running (a CPU-n fut), Blocked/Waiting (erőforrásra vagy értesítésre vár), Terminated (befejezve). Az állapotok közötti átmeneteket az operációs rendszer ütemezője és a szinkronizálási primitívek irányítják. A fejlesztő befolyásolhatja a szál prioritását (Thread.setPriority()) és állapotát (sleep, join, interrupt).

Androidon a szál Blocked állapotba kerül, amikor foglalt monitort próbál megszerezni (synchronized), Object.wait() vagy Thread.sleep() hívásakor. iOS-en — NSCondition.wait(), pthread_cond_wait() vagy dispatch_semaphore_wait() hívásakor. Blocked állapotban a szál nem fogyaszt CPU-t, de memóriát foglal (verem). A szál másik szálból megszakítható (interrupted), InterruptedException (Java) fogadásával vagy isCancelled (Kotlin Coroutines) ellenőrzésével.

Context Switch és költsége

Context switch (kontextusváltás) — az a művelet, amelynek során az operációs rendszer elmenti az aktuális szál állapotát (regiszterek, PC, TLB), és betölti egy másik elmentett állapotát. A mobil rendszerekben (Linux + ART, iOS-hez XNU) a context switch 1–10 mikroszekundumig tart. Ha egy szál 100 mikroszekundum alatt hajt végre egy feladatot, a context switch pedig 5-ig tart, akkor az idő 5%-a vész el. A context switch minimalizálásához az iOS work stealing-el használja a GCD-t, az Android pedig fixedThreadCount-poolokat.

Thread Androidon: a Thread-től a Coroutines-ig

Az Android az alacsony szintű java.lang.Thread-től a modern korutinokig fejlődött. Az absztrakció minden szintje több lehetőséget ad kisebb többletköltséggel. A Thread az alapsztály, de közvetlen létrehozása nem ajánlott: az új szálat nem kezeli pool, nehéz nyomon követni és megszakítani. Az AsyncTask (API 30-tól deprecated) előrelépés volt, de memóriavesztéstől és a konfigurációk kényelmetlen kezelésétől szenvedett.

A HandlerThread — a Thread speciális alosztálya Looper-rel, amely üzenetsort tud feldolgozni. Háttérszálon futó feladatok szekvenciális végrehajtására használják, például adatok Room-ba vagy fájlokba írására. A HandlerThread a start() hívással jön létre, majd a Handler(handlerThread.looper) révén üzeneteket és Runnable-t lehet küldeni. A handlerThread.quit() hívás leállítja a Looper-t és befejezi a szálat.

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

class ThreadExample {

    // 1. A Thread közvetlen létrehozása (nem ajánlott)
    fun directThread() {
        val thread = Thread(Runnable {
            Thread.sleep(1000)
            print("Közvetlen szál végrehajtva")
        })
        thread.start()
    }

    // 2. HandlerThread szekvenciális háttérfeladatokhoz
    fun handlerThreadExample() {
        val handlerThread = HandlerThread("BackgroundQueue")
        handlerThread.start()

        val handler = Handler(handlerThread.looper)
        handler.post {
            // Szekvenciális végrehajtás háttérszálon
            Thread.sleep(500)
            print("HandlerThread: a feladat végrehajtva")
        }

        // Szál leállítása (akkor fut le, amikor a feladatok befejeződnek)
        handlerThread.quitSafely()
    }

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

A ThreadExample példa mind a négy szálabsztrakciós szintet megmutatja Androidon. A Thread közvetlen létrehozása a legalacsonyabb szintű és leghatékonyatlanabb megközelítés. A HandlerThread hasznos a háttérben futó szekvenciális feladatokhoz. Az Executors.newFixedThreadPool(4) 4 szálból álló poolt hoz létre legfeljebb 10 feladat párhuzamos végrehajtásához. A Kotlin Coroutines a Dispatchers.Default-tal — modern, hatékony és biztonságos módszer.

HandlerThread: szekvenciális háttérfeladatok

HandlerThread — a Thread specializált alosztálya beépített Looper-rel és üzenetsorral. A start() hívással jön létre, majd a Handler(handlerThread.looper) révén Runnable és üzenetek küldhetők. A HandlerThread a feladatokat szigorúan szekvenciálisan hajtja végre — a következő feladat nem kezdődik el az előző befejezéséig. Ez kényelmes a Room-ba vagy fájlokba íráskor, ahol a műveletek sorrendje kritikus. A quitSafely() hívás az aktuális feladat befejezése után állítja le a Looper-t.

import Foundation

class ThreadManager {

    // 1. Thread (alacsony szintű)
    func createThread() {
        let thread = Thread {
            // A kód új szálon fut
            print("Current thread: \(Thread.current)")
        }
        thread.name = "com.app.worker"
        thread.qualityOfService = .utility
        thread.start()
    }

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

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

        // Barrier az írás szinkronizálásához
        queue.async(flags: .barrier) {
            // Exkluzív hozzáférés írás közben
            print("Barrier write: exkluzív hozzáférés")
        }
    }

    // 3. OperationQueue függőségekkel
    func operationQueueExample() {
        let queue = OperationQueue()
        queue.maxConcurrentOperationCount = 2
        queue.qualityOfService = .background

        let download = BlockOperation {
            print("Letöltés...")
        }
        let process = BlockOperation {
            print("Feldolgozás...")
        }
        let save = BlockOperation {
            print("Mentés...")
        }

        // Függőségek: download -> process -> save
        process.addDependency(download)
        save.addDependency(process)

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

// Thread-safe gyűjtemény GCD barrieren keresztül
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)
        }
    }
}

// Szinkronizálás Android/Kotlin környezetben
import java.util.concurrent.atomic.AtomicInteger
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock

class Counter {

    // 1. AtomicInteger — egyszerű számlálókhoz
    private val atomicCount = AtomicInteger(0)
    fun incrementAtomic() = atomicCount.incrementAndGet()

    // 2. synchronized — kritikus szakaszokhoz
    @Synchronized
    fun synchronizedOperation() {
        // Egyszerre csak egy szál
        doWork()
    }

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

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

// Deadlock-példa: A blokkolja B-t, B blokkolja A-t
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") }
    }
}