Thread in mobiele ontwikkeling — wat is het, typen en beheer van threads

Wat is Thread

Thread (uitvoeringsdraad) — een onafhankelijke reeks instructies die het besturingssysteem op een CPU-kern kan plannen. Elk proces (app) bevat ten minste één thread — Main Thread. Extra threads worden aangemaakt voor parallelle uitvoering van taken. Elke thread heeft een eigen programmastack (met lokale variabelen), een programmateller (PC) en registers. Het heap-geheugen wordt gedeeld door alle threads van het proces.

In mobiele besturingssystemen worden threads gepland via preëmptieve multitasking: het besturingssysteem kan de uitvoering van een thread op elk moment onderbreken en de controle overdragen aan een andere (context switch). Het wisselen van context is een dure bewerking (1–10 microseconden), omdat het CPU-registers moet opslaan/herstellen, de TLB moet bijwerken en caches moet legen. Precies daarom verslechtert een overmatig aantal threads (honderden en duizenden) de prestaties — het besturingssysteem besteedt meer tijd aan wisselen dan aan uitvoeren.

Thread en proces zijn verschillende begrippen. Een proces is een instantie van een app met toegewezen virtueel geheugen. Een thread binnen een proces deelt dat geheugen met andere threads. In Android werkt elk component van de app (Activity, Service, BroadcastReceiver) in één proces, maar kan in verschillende threads worden uitgevoerd. Een iOS-app is ook één proces met de mogelijkheid om extra threads te maken via GCD of Thread.

De levenscyclus van een thread: toestanden en overgangen

Elke thread in Java/Kotlin (Android) en NSThread (iOS) doorloopt vijf toestanden: New (aangemaakt), Runnable (klaar voor uitvoering), Running (draait op de CPU), Blocked/Waiting (wacht op een bron of melding), Terminated (beëindigd). De overgangen tussen toestanden worden beheerd door de scheduler van het besturingssysteem en synchronisatie-primitieven. De ontwikkelaar kan de prioriteit van de thread (Thread.setPriority()) en de toestand ervan (sleep, join, interrupt) beïnvloeden.

In Android gaat een thread naar de toestand Blocked bij een poging om een bezette monitor te veroveren (synchronized), bij een aanroep van Object.wait() of Thread.sleep(). In iOS — bij een aanroep van NSCondition.wait(), pthread_cond_wait() of dispatch_semaphore_wait(). In de toestand Blocked verbruikt de thread geen CPU, maar wel geheugen (stack). Een thread kan vanuit een andere thread worden onderbroken (interrupted), met een InterruptedException (Java) of door isCancelled te controleren (Kotlin Coroutines).

Context Switch en de kosten ervan

Context switch (contextwisseling) — de bewerking waarbij het besturingssysteem de toestand van de huidige thread (registers, PC, TLB) opslaat en de opgeslagen toestand van een andere laadt. In mobiele systemen (Linux + ART, XNU voor iOS) duurt een context switch 1–10 microseconden. Als een thread een taak in 100 microseconden uitvoert en een context switch 5 duurt, gaat 5% van de tijd verloren. Om context switches te minimaliseren gebruikt iOS GCD met work stealing, en Android pools met fixedThreadCount.

Thread in Android: van Thread tot Coroutines

Android is geëvolueerd van het laagniveau java.lang.Thread naar moderne coroutines. Elk abstractieniveau biedt meer mogelijkheden met lagere overhead. Thread is de basisklasse, maar directe aanmaak wordt niet aangeraden: de nieuwe thread wordt niet door een pool beheerd en is moeilijk te monitoren en te annuleren. AsyncTask (deprecated vanaf API 30) was een stap vooruit, maar leed aan geheugenlekken en onhandige verwerking van configuraties.

HandlerThread — een speciale subklasse van Thread met een Looper, die een berichtenwachtrij kan verwerken. Wordt gebruikt voor sequentiële uitvoering van taken op een achtergrondthread, bijvoorbeeld het wegschrijven van gegevens naar Room of bestanden. HandlerThread wordt aangemaakt met een aanroep van start(), waarna via Handler(handlerThread.looper) berichten en Runnable kunnen worden verzonden. De aanroep handlerThread.quit() stopt de Looper en beëindigt de thread.

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

class ThreadExample {

    // 1. Direct aanmaken van Thread (niet aanbevolen)
    fun directThread() {
        val thread = Thread(Runnable {
            Thread.sleep(1000)
            print("Directe thread uitgevoerd")
        })
        thread.start()
    }

    // 2. HandlerThread voor sequentiële achtergrondtaken
    fun handlerThreadExample() {
        val handlerThread = HandlerThread("BackgroundQueue")
        handlerThread.start()

        val handler = Handler(handlerThread.looper)
        handler.post {
            // Sequentiële uitvoering op de achtergrondthread
            Thread.sleep(500)
            print("HandlerThread: taak uitgevoerd")
        }

        // Thread stoppen (uitgevoerd wanneer de taken zijn voltooid)
        handlerThread.quitSafely()
    }

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

Het voorbeeld ThreadExample toont alle vier abstractieniveaus van threads in Android. Directe aanmaak van Thread is de laagstniveau- en inefficiëntste benadering. HandlerThread is nuttig voor sequentiële taken op de achtergrond. Executors.newFixedThreadPool(4) maakt een pool van 4 threads voor parallelle uitvoering van maximaal 10 taken. Kotlin Coroutines met Dispatchers.Default — een moderne, efficiënte en veilige methode.

HandlerThread: sequentiële achtergrondtaken

HandlerThread — een gespecialiseerde subklasse van Thread met ingebouwde Looper en berichtenwachtrij. Wordt aangemaakt met een aanroep van start(), waarna via Handler(handlerThread.looper) Runnable en berichten kunnen worden verzonden. HandlerThread voert taken strikt sequentieel uit — de volgende taak begint niet voordat de vorige is voltooid. Dit is handig bij het wegschrijven van gegevens naar Room of bestanden, waar de volgorde van bewerkingen cruciaal is. De aanroep quitSafely() stopt de Looper na voltooiing van de huidige taak.

import Foundation

class ThreadManager {

    // 1. Thread (laag niveau)
    func createThread() {
        let thread = Thread {
            // De code wordt op een nieuwe thread uitgevoerd
            print("Current thread: \(Thread.current)")
        }
        thread.name = "com.app.worker"
        thread.qualityOfService = .utility
        thread.start()
    }

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

        queue.async {
            print("GCD async-taak")
        }

        // Barrier voor synchronisatie van schrijven
        queue.async(flags: .barrier) {
            // Exclusieve toegang tijdens het schrijven
            print("Barrier write: exclusieve toegang")
        }
    }

    // 3. OperationQueue met afhankelijkheden
    func operationQueueExample() {
        let queue = OperationQueue()
        queue.maxConcurrentOperationCount = 2
        queue.qualityOfService = .background

        let download = BlockOperation {
            print("Bezig met downloaden...")
        }
        let process = BlockOperation {
            print("Bezig met verwerken...")
        }
        let save = BlockOperation {
            print("Bezig met opslaan...")
        }

        // Afhankelijkheden: download -> process -> save
        process.addDependency(download)
        save.addDependency(process)

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

// Thread-safe collectie via 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)
        }
    }
}

// Synchronisatie in Android/Kotlin
import java.util.concurrent.atomic.AtomicInteger
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock

class Counter {

    // 1. AtomicInteger — voor eenvoudige tellers
    private val atomicCount = AtomicInteger(0)
    fun incrementAtomic() = atomicCount.incrementAndGet()

    // 2. synchronized — voor kritieke secties
    @Synchronized
    fun synchronizedOperation() {
        // Slechts één thread tegelijk
        doWork()
    }

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

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

// Deadlock-voorbeeld: A vergrendelt B, B vergrendelt 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") }
    }
}