Thread in der mobilen Entwicklung — was es ist, Typen und Thread-Verwaltung

Was ist ein Thread

Thread (Ausführungsfaden) — eine unabhängige Sequenz von Anweisungen, die das Betriebssystem auf einem CPU-Kern planen kann. Jeder Prozess (Anwendung) enthält mindestens einen Thread — den Main Thread. Zusätzliche Threads werden für die parallele Ausführung von Aufgaben erstellt. Jeder Thread hat seinen eigenen Programmstack (mit lokalen Variablen), einen Befehlszähler (PC) und Register. Der Heap-Speicher wird von allen Threads des Prozesses gemeinsam genutzt.

In mobilen Betriebssystemen werden Threads durch präemptives Multitasking geplant: Das BS kann die Ausführung eines Threads jederzeit unterbrechen und die Kontrolle an einen anderen übergeben (Context Switch). Der Kontextwechsel ist eine teure Operation (1-10 Mikrosekunden), da er das Speichern/Wiederherstellen von CPU-Registern, das Aktualisieren des TLB und das Leeren von Caches erfordert. Aus diesem Grund verschlechtert eine übermäßige Anzahl von Threads (Hunderte und Tausende) die Leistung — das BS verbringt mehr Zeit mit dem Wechseln als mit dem Ausführen.

Thread und Prozess — unterschiedliche Konzepte. Ein Prozess ist eine Instanz einer Anwendung mit dediziertem virtuellem Speicher. Ein Thread innerhalb eines Prozesses teilt diesen Speicher mit anderen Threads. In Android arbeitet jede Komponente der Anwendung (Activity, Service, BroadcastReceiver) in einem Prozess, kann aber in verschiedenen Threads ausgeführt werden. Eine iOS-Anwendung ist ebenfalls ein einzelner Prozess mit der Möglichkeit, über GCD oder Thread zusätzliche Threads zu erstellen.

Lebenszyklus eines Threads: Zustände und Übergänge

Jeder Thread in Java/Kotlin (Android) und NSThread (iOS) durchläuft fünf Zustände: New (erstellt), Runnable (bereit zur Ausführung), Running (auf CPU ausführend), Blocked/Waiting (wartet auf Ressource oder Benachrichtigung), Terminated (beendet). Die Übergänge zwischen den Zuständen werden vom BS-Planer und Synchronisationsprimitive verwaltet. Der Entwickler kann die Priorität des Threads (Thread.setPriority()) und seinen Zustand (sleep, join, interrupt) beeinflussen.

In Android wechselt ein Thread in den Zustand Blocked, wenn er versucht, einen belegten Monitor (synchronized) zu erfassen, Object.wait() oder Thread.sleep() aufruft. In iOS — beim Aufruf von NSCondition.wait(), pthread_cond_wait() oder dispatch_semaphore_wait(). Im Zustand Blocked verbraucht der Thread keine CPU, belegt aber Speicher (Stack). Ein Thread kann von einem anderen Thread unterbrochen (interrupted) werden und erhält eine InterruptedException (Java) oder isCancelled (Kotlin Coroutines).

Context Switch und seine Kosten

Context Switch (Kontextwechsel) — eine Operation, bei der das BS den Zustand des aktuellen Threads (Register, PC, TLB) speichert und den gespeicherten Zustand eines anderen lädt. In mobilen Systemen (Linux + ART, XNU für iOS) dauert ein Context Switch 1-10 Mikrosekunden. Wenn ein Thread eine Aufgabe in 100 Mikrosekunden ausführt und der Context Switch 5 dauert, werden 5% der Zeit verschwendet. Zur Minimierung des Context Switch verwendet iOS GCD mit Work Stealing, Android — Pools mit fixedThreadCount.

Thread in Android: Von Thread zu Coroutines

Android hat sich von java.lang.Thread auf niedriger Ebene zu modernen Coroutines entwickelt. Jede Abstraktionsebene bietet mehr Möglichkeiten bei geringerem Overhead. Thread ist die Basisklasse, aber seine direkte Erstellung wird nicht empfohlen: Der neue Thread wird nicht von einem Pool verwaltet, ist schwer zu überwachen und abzubrechen. AsyncTask (seit API 30 veraltet) war ein Schritt nach vorne, litt aber unter Speicherlecks und unbequemer Konfigurationsbehandlung.

HandlerThread — eine spezielle Unterklasse von Thread mit Looper, die eine Nachrichtenwarteschlange verarbeiten kann. Es wird für die sequenzielle Ausführung von Aufgaben in einem Hintergrundthread verwendet, z.B. zum Schreiben von Daten in Room oder Dateien. HandlerThread wird durch Aufruf von start() erstellt, danach können über Handler(handlerThread.looper) Nachrichten und Runnable gesendet werden. Der Aufruf handlerThread.quit() stoppt den Looper und beendet den Thread.

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

class ThreadExample {

    // 1. Direkte Thread-Erstellung (nicht empfohlen)
    fun directThread() {
        val thread = Thread(Runnable {
            Thread.sleep(1000)
            print("Direct thread executed")
        })
        thread.start()
    }

    // 2. HandlerThread für sequenzielle Hintergrundaufgaben
    fun handlerThreadExample() {
        val handlerThread = HandlerThread("BackgroundQueue")
        handlerThread.start()

        val handler = Handler(handlerThread.looper)
        handler.post {
            // Sequentielle Ausführung im Hintergrundthread
            Thread.sleep(500)
            print("HandlerThread: Aufgabe abgeschlossen")
        }

        // Thread stoppen (wird ausgeführt, wenn Aufgaben abgeschlossen sind)
        handlerThread.quitSafely()
    }

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

Das Beispiel ThreadExample zeigt alle vier Abstraktionsebenen von Threads in Android. Die direkte Erstellung von Thread ist der niedrigste und ineffizienteste Ansatz. HandlerThread ist nützlich für sequenzielle Aufgaben im Hintergrund. Executors.newFixedThreadPool(4) erstellt einen Pool von 4 Threads für die parallele Ausführung von bis zu 10 Aufgaben. Kotlin Coroutines mit Dispatchers.Default — die moderne, effiziente und sichere Methode.

HandlerThread: Sequenzielle Hintergrundaufgaben

HandlerThread — eine spezialisierte Unterklasse von Thread mit integriertem Looper und Nachrichtenwarteschlange. Es wird durch Aufruf von start() erstellt, danach können über Handler(handlerThread.looper) Runnable und Nachrichten gesendet werden. HandlerThread führt Aufgaben streng sequenziell aus — die nächste Aufgabe beginnt erst nach Abschluss der vorherigen. Dies ist praktisch zum Schreiben von Daten in Room oder Dateien, wo die Reihenfolge der Operationen kritisch ist. Der Aufruf quitSafely() stoppt den Looper nach Abschluss der aktuellen Aufgabe.

import Foundation

class ThreadManager {

    // 1. Thread (niedrige Ebene)
    func createThread() {
        let thread = Thread {
            // Code wird in neuem Thread ausgeführt
            print("Current thread: \(Thread.current)")
        }
        thread.name = "com.app.worker"
        thread.qualityOfService = .utility
        thread.start()
    }

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

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

        // Barrier zur Schreibsynchronisation
        queue.async(flags: .barrier) {
            // Exklusiver Zugriff während des Schreibens
            print("Barrier write: exclusive access")
        }
    }

    // 3. OperationQueue mit Abhängigkeiten
    func operationQueueExample() {
        let queue = OperationQueue()
        queue.maxConcurrentOperationCount = 2
        queue.qualityOfService = .background

        let download = BlockOperation {
            print("Downloading...")
        }
        let process = BlockOperation {
            print("Processing...")
        }
        let save = BlockOperation {
            print("Saving...")
        }

        // Abhängigkeiten: download -> process -> save
        process.addDependency(download)
        save.addDependency(process)

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

// Thread-sichere Sammlung über 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)
        }
    }
}

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

class Counter {

    // 1. AtomicInteger — für einfache Zähler
    private val atomicCount = AtomicInteger(0)
    fun incrementAtomic() = atomicCount.incrementAndGet()

    // 2. synchronized — für kritische Abschnitte
    @Synchronized
    fun synchronizedOperation() {
        // Nur ein Thread gleichzeitig
        doWork()
    }

    // 3. Mutex aus Coroutines — suspend-safe
    private val mutex = Mutex()
    suspend fun mutexOperation() {
        mutex.withLock {
            // Geschützter Code — threadsicher
            doWork()
        }
    }

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

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