Thread inom mobilutveckling — vad är det, typer och hantering av trådar

Vad är Thread

Thread (exekveringstråd) — en oberoende sekvens av instruktioner som operativsystemet kan schemalägga på en CPU-kärna. Varje process (app) innehåller minst en tråd — Main Thread. Extra trådar skapas för parallell exekvering av uppgifter. Varje tråd har en egen programstack (med lokala variabler), en programräknare (PC) och register. Heap-minnet är delat av alla trådar i processen.

I mobila operativsystem schemaläggs trådar med förebyggande multitasking (preemptive multitasking): operativsystemet kan när som helst avbryta en tråds exekvering och lämna över kontrollen till en annan (context switch). Kontextbyte är en dyr operation (1–10 mikrosekunder), eftersom det kräver att CPU-register sparas/återställs, TLB uppdateras och cacheminnen töms. Just därför försämrar ett alltför stort antal trådar (hundratals och tusentals) prestandan — operativsystemet lägger mer tid på växling än på exekvering.

Tråd och process är olika begrepp. En process är en instans av appen med dedikerat virtuellt minne. En tråd i processen delar detta minne med andra trådar. I Android fungerar varje komponent i appen (Activity, Service, BroadcastReceiver) i en process, men kan köras i olika trådar. En iOS-app är också en enda process med möjlighet att skapa extra trådar via GCD eller Thread.

Trådens livscykel: tillstånd och övergångar

Varje tråd i Java/Kotlin (Android) och NSThread (iOS) går igenom fem tillstånd: New (skapad), Runnable (redo att köras), Running (körs på CPU), Blocked/Waiting (väntar på en resurs eller notifiering), Terminated (avslutad). Övergångarna mellan tillstånden hanteras av operativsystemets schemaläggare och synkroniseringsprimitiver. Utvecklaren kan påverka trådens prioritet (Thread.setPriority()) och dess tillstånd (sleep, join, interrupt).

I Android går en tråd till tillståndet Blocked vid försök att ta en upptagen monitor (synchronized), vid anrop av Object.wait() eller Thread.sleep(). I iOS — vid anrop av NSCondition.wait(), pthread_cond_wait() eller dispatch_semaphore_wait(). I tillståndet Blocked förbrukar tråden inte CPU, men upptar minne (stack). En tråd kan avbrytas (interrupted) från en annan tråd, genom att få InterruptedException (Java) eller genom att kontrollera isCancelled (Kotlin Coroutines).

Context Switch och dess kostnad

Context switch (kontextbyte) — operationen där operativsystemet sparar den aktuella trådens tillstånd (register, PC, TLB) och läser in ett annat tillstånd. I mobila system (Linux + ART, XNU för iOS) tar context switch 1–10 mikrosekunder. Om en tråd kör en uppgift på 100 mikrosekunder och context switch tar 5, går 5% av tiden förlorad. För att minimera context switch använder iOS GCD med work stealing, och Android pooler med fixedThreadCount.

Thread i Android: från Thread till Coroutines

Android har utvecklats från den lågnivåbaserade java.lang.Thread till moderna koroutiner. Varje abstraktionsnivå ger fler möjligheter med lägre overhead. Thread är basklassen, men direkt skapande rekommenderas inte: den nya tråden hanteras inte av en pool och är svår att övervaka och avbryta. AsyncTask (deprecated sedan API 30) var ett steg framåt, men led av minnesläckor och obekväm hantering av konfigurationer.

HandlerThread — en speciell underklass av Thread med Looper, som kan bearbeta en meddelandekö. Används för sekventiell exekvering av uppgifter på en bakgrundstråd, till exempel att skriva data till Room eller filer. HandlerThread skapas med ett anrop av start(), varefter man via Handler(handlerThread.looper) kan skicka meddelanden och Runnable. Anropet handlerThread.quit() stoppar Looper och avslutar tråden.

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

class ThreadExample {

    // 1. Direkt skapande av Thread (rekommenderas inte)
    fun directThread() {
        val thread = Thread(Runnable {
            Thread.sleep(1000)
            print("Direkt tråd exekverad")
        })
        thread.start()
    }

    // 2. HandlerThread för sekventiella bakgrundsuppgifter
    fun handlerThreadExample() {
        val handlerThread = HandlerThread("BackgroundQueue")
        handlerThread.start()

        val handler = Handler(handlerThread.looper)
        handler.post {
            // Sekventiell exekvering på bakgrundstråden
            Thread.sleep(500)
            print("HandlerThread: uppgift utförd")
        }

        // Stoppa tråden (körs när uppgifterna är klara)
        handlerThread.quitSafely()
    }

    // 3. Executors — trådpool
    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()}")
    }
}

Exemplet ThreadExample visar alla fyra abstraktionsnivåer för trådar i Android. Direkt skapande av Thread är det mest lågnivåbaserade och ineffektiva tillvägagångssättet. HandlerThread är användbart för sekventiella uppgifter i bakgrunden. Executors.newFixedThreadPool(4) skapar en pool med 4 trådar för parallell exekvering av upp till 10 uppgifter. Kotlin Coroutines med Dispatchers.Default — en modern, effektiv och säker metod.

HandlerThread: sekventiella bakgrundsuppgifter

HandlerThread — en specialiserad underklass av Thread med inbyggd Looper och meddelandekö. Skapas med ett anrop av start(), varefter man via Handler(handlerThread.looper) kan skicka Runnable och meddelanden. HandlerThread kör uppgifter strikt sekventiellt — nästa uppgift startar inte förrän den föregående är klar. Detta är bekvämt vid skrivning av data till Room eller filer, där ordningen på operationer är kritisk. Anropet quitSafely() stoppar Looper efter att den aktuella uppgiften är klar.

import Foundation

class ThreadManager {

    // 1. Thread (låg nivå)
    func createThread() {
        let thread = Thread {
            // Koden körs på en ny tråd
            print("Current thread: \(Thread.current)")
        }
        thread.name = "com.app.worker"
        thread.qualityOfService = .utility
        thread.start()
    }

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

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

        // Barrier för synkronisering av skrivning
        queue.async(flags: .barrier) {
            // Exklusiv åtkomst under skrivning
            print("Barrier write: exklusiv åtkomst")
        }
    }

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

        let download = BlockOperation {
            print("Laddar ner...")
        }
        let process = BlockOperation {
            print("Bearbetar...")
        }
        let save = BlockOperation {
            print("Sparar...")
        }

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

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

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

// Synkronisering i Android/Kotlin
import java.util.concurrent.atomic.AtomicInteger
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock

class Counter {

    // 1. AtomicInteger — för enkla räknare
    private val atomicCount = AtomicInteger(0)
    fun incrementAtomic() = atomicCount.incrementAndGet()

    // 2. synchronized — för kritiska sektioner
    @Synchronized
    fun synchronizedOperation() {
        // Endast en tråd åt gången
        doWork()
    }

    // 3. Mutex från koroutiner — suspend-safe
    private val mutex = Mutex()
    suspend fun mutexOperation() {
        mutex.withLock {
            // protected code — trådsäker
            doWork()
        }
    }

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

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