Thread w tworzeniu aplikacji mobilnych — co to jest, rodzaje i zarządzanie wątkami

Co to jest Thread

Thread (wątek wykonawczy) to niezależna sekwencja instrukcji, którą system operacyjny może zaplanować na rdzeniu CPU. Każdy proces (aplikacja) zawiera co najmniej jeden wątek — Main Thread. Dodatkowe wątki są tworzone do równoległego wykonywania zadań. Każdy wątek ma własny stos programowy (z lokalnymi zmiennymi), licznik rozkazów (PC) i rejestry. Pamięć sterty (heap) jest wspólna dla wszystkich wątków procesu.

W mobilnych systemach operacyjnych wątki są planowane przez wywłaszczającą wielozadaniowość (preemptive multitasking): system operacyjny może przerwać wykonanie wątku w dowolnym momencie i przekazać sterowanie innemu (context switch). Przełączanie kontekstu to kosztowna operacja (1–10 mikrosekund), ponieważ wymaga zapisania i przywrócenia rejestrów CPU, zaktualizowania TLB oraz wyczyszczenia pamięci podręcznych. Dlatego nadmierna liczba wątków (setki i tysiące) pogarsza wydajność — system operacyjny poświęca więcej czasu na przełączanie niż na wykonywanie.

Wątek a proces to różne pojęcia. Proces to instancja aplikacji z wydzieloną pamięcią wirtualną. Wątek wewnątrz procesu dzieli tę pamięć z innymi wątkami. W Android każdy komponent aplikacji (Activity, Service, BroadcastReceiver) działa w jednym procesie, ale może wykonywać się w różnych wątkach. Aplikacja iOS również jest jednym procesem z możliwością tworzenia dodatkowych wątków przez GCD lub Thread.

Cykl życia wątku: stany i przejścia

Każdy wątek w Java/Kotlin (Android) i NSThread (iOS) przechodzi przez pięć stanów: New (utworzony), Runnable (gotowy do wykonania), Running (wykonywany na CPU), Blocked/Waiting (oczekuje na zasób lub powiadomienie), Terminated (zakończony). Przejścia między stanami są zarządzane przez planistę systemu operacyjnego i prymitywy synchronizacji. Programista może wpływać na priorytet wątku (Thread.setPriority()) i jego stan (sleep, join, interrupt).

W Android wątek przechodzi w stan Blocked przy próbie zajęcia zajętego monitora (synchronized), wywołaniu Object.wait() lub Thread.sleep(). W iOS — przy wywołaniu NSCondition.wait(), pthread_cond_wait() lub dispatch_semaphore_wait(). W stanie Blocked wątek nie zużywa CPU, ale zajmuje pamięć (stos). Wątek może być przerwany (interrupted) z innego wątku, otrzymując InterruptedException (Java) lub sprawdzając isCancelled (Kotlin Coroutines).

Context Switch i jego koszt

Context switch (przełączanie kontekstu) to operacja, w której system operacyjny zapisuje stan bieżącego wątku (rejestry, PC, TLB) i wczytuje zapisany stan innego. W systemach mobilnych (Linux + ART, XNU dla iOS) context switch trwa 1–10 mikrosekund. Jeśli wątek wykonuje zadanie w 100 mikrosekund, a context switch zajmuje 5, to 5% czasu jest tracone. Aby zminimalizować context switch, iOS używa GCD z work stealing, Android — puli z fixedThreadCount.

Thread w Android: od Thread do Coroutines

Android przeszedł ewolucję od niskopoziomowego java.lang.Thread do nowoczesnych korutyn. Każdy poziom abstrakcji daje więcej możliwości przy mniejszych kosztach ogólnych. Thread to klasa bazowa, ale jej bezpośrednie tworzenie nie jest zalecane: nowy wątek nie jest zarządzany przez pulę, trudno go monitorować i anulować. AsyncTask (deprecated od API 30) był krokiem naprzód, ale cierpiał na wycieki pamięci i niewygodną obsługę konfiguracji.

HandlerThread to specjalna podklasa Thread z Looper, która może przetwarzać kolejkę komunikatów. Jest używana do sekwencyjnego wykonywania zadań w wątku tła, na przykład zapisu danych do Room lub plików. HandlerThread jest tworzony wywołaniem start(), po czym przez Handler(handlerThread.looper) można wysyłać komunikaty i Runnable. Wywołanie handlerThread.quit() zatrzymuje Looper i kończy wątek.

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

class ThreadExample {

    // 1. Bezpośrednie tworzenie Thread (niezalecane)
    fun directThread() {
        val thread = Thread(Runnable {
            Thread.sleep(1000)
            print("Bezpośredni wątek wykonany")
        })
        thread.start()
    }

    // 2. HandlerThread do sekwencyjnych zadań w tle
    fun handlerThreadExample() {
        val handlerThread = HandlerThread("BackgroundQueue")
        handlerThread.start()

        val handler = Handler(handlerThread.looper)
        handler.post {
            // Sekwencyjne wykonywanie w wątku tła
            Thread.sleep(500)
            print("HandlerThread: zadanie wykonane")
        }

        // Zatrzymanie wątku (wykonywane, gdy zadania się zakończą)
        handlerThread.quitSafely()
    }

    // 3. Executors — pula wątków
    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 — nowoczesny standard
    suspend fun coroutineExample() = kotlinx.coroutines.withContext(
        kotlinx.coroutines.Dispatchers.Default
    ) {
        print("Coroutine on thread: ${Thread.currentThread().getName()}")
    }
}

Przykład ThreadExample pokazuje wszystkie cztery poziomy abstrakcji wątków w Android. Bezpośrednie tworzenie Thread to najbardziej niskopoziomowe i nieefektywne podejście. HandlerThread jest przydatny do sekwencyjnych zadań w tle. Executors.newFixedThreadPool(4) tworzy pulę z 4 wątków do równoległego wykonywania do 10 zadań. Kotlin Coroutines z Dispatchers.Default to nowoczesny, efektywny i bezpieczny sposób.

HandlerThread: sekwencyjne zadania w tle

HandlerThread to wyspecjalizowana podklasa Thread z wbudowanym Looper i kolejką komunikatów. Tworzy się go wywołaniem start(), po czym przez Handler(handlerThread.looper) można wysyłać Runnable i komunikaty. HandlerThread wykonuje zadania ściśle sekwencyjnie — następne zadanie nie rozpocznie się przed zakończeniem poprzedniego. Jest to wygodne przy zapisie danych do Room lub plików, gdzie kolejność operacji jest krytyczna. Wywołanie quitSafely() zatrzymuje Looper po zakończeniu bieżącego zadania.

import Foundation

class ThreadManager {

    // 1. Thread (niskopoziomowy)
    func createThread() {
        let thread = Thread {
            // Kod wykonuje się w nowym wątku
            print("Current thread: \(Thread.current)")
        }
        thread.name = "com.app.worker"
        thread.qualityOfService = .utility
        thread.start()
    }

    // 2. GCD — DispatchQueue
    func gcdExample() {
        // Kolejka równoległa
        let queue = DispatchQueue(label: "com.app.concurrent",
                                 qos: .utility,
                                 attributes: .concurrent)

        queue.async {
            print("Zadanie asynchroniczne GCD")
        }

        // Barrier do synchronizacji zapisu
        queue.async(flags: .barrier) {
            // Ekskluzywny dostęp podczas zapisu
            print("Barrier write: dostęp ekskluzywny")
        }
    }

    // 3. OperationQueue z zależnościami
    func operationQueueExample() {
        let queue = OperationQueue()
        queue.maxConcurrentOperationCount = 2
        queue.qualityOfService = .background

        let download = BlockOperation {
            print("Pobieranie...")
        }
        let process = BlockOperation {
            print("Przetwarzanie...")
        }
        let save = BlockOperation {
            print("Zapisywanie...")
        }

        // Zależności: download -> process -> save
        process.addDependency(download)
        save.addDependency(process)

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

// Kolekcja bezpieczna dla wątków przez 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)
        }
    }
}

// Synchronizacja w Android/Kotlin
import java.util.concurrent.atomic.AtomicInteger
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock

class Counter {

    // 1. AtomicInteger — dla prostych liczników
    private val atomicCount = AtomicInteger(0)
    fun incrementAtomic() = atomicCount.incrementAndGet()

    // 2. synchronized — dla sekcji krytycznych
    @Synchronized
    fun synchronizedOperation() {
        // Tylko jeden wątek na raz
        doWork()
    }

    // 3. Mutex z korutyn — suspend-safe
    private val mutex = Mutex()
    suspend fun mutexOperation() {
        mutex.withLock {
            // protected code — bezpieczne dla wątków
            doWork()
        }
    }

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

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