Thread nello sviluppo mobile — cosa sono, tipi e gestione dei thread

Cos'è un Thread

Thread (filo di esecuzione) — è una sequenza indipendente di istruzioni che il sistema operativo può schedulare su un core della CPU. Ogni processo (applicazione) contiene almeno un thread — il Main Thread. Thread aggiuntivi vengono creati per l'esecuzione parallela dei task. Ogni thread ha il proprio stack software (con variabili locali), un contatore di programma (PC) e registri. La memoria heap è condivisa da tutti i thread del processo.

Nei sistemi operativi mobili, i thread vengono schedulati con multitasking preemptive: l'OS può interrompere l'esecuzione di un thread in qualsiasi momento e passare il controllo a un altro (context switch). Il cambio di contesto è un'operazione costosa (1-10 microsecondi), poiché richiede il salvataggio/ripristino dei registri della CPU, l'aggiornamento del TLB e lo svuotamento delle cache. È per questo che un numero eccessivo di thread (centinaia o migliaia) degrada le prestazioni — l'OS spende più tempo nei cambi di contesto che nell'esecuzione.

Thread e processo — sono concetti diversi. Un processo è un'istanza dell'applicazione con memoria virtuale dedicata. Un thread all'interno di un processo condivide questa memoria con altri thread. In Android, ogni componente dell'applicazione (Activity, Service, BroadcastReceiver) opera in un singolo processo, ma può eseguirsi su thread diversi. Un'applicazione iOS è anch'essa un singolo processo con la possibilità di creare thread aggiuntivi tramite GCD o Thread.

Ciclo di vita del thread: stati e transizioni

Ogni thread in Java/Kotlin (Android) e NSThread (iOS) attraversa cinque stati: New (creato), Runnable (pronto per l'esecuzione), Running (in esecuzione sulla CPU), Blocked/Waiting (attende una risorsa o una notifica), Terminated (terminato). Le transizioni tra gli stati sono gestite dallo scheduler dell'OS e dalle primitive di sincronizzazione. Lo sviluppatore può influenzare la priorità del thread (Thread.setPriority()) e il suo stato (sleep, join, interrupt).

In Android, un thread passa allo stato Blocked quando tenta di acquisire un monitor occupato (synchronized), chiama Object.wait() o Thread.sleep(). In iOS — quando chiama NSCondition.wait(), pthread_cond_wait() o dispatch_semaphore_wait(). Nello stato Blocked, il thread non consuma CPU ma occupa memoria (stack). Un thread può essere interrotto (interrupted) da un altro thread, ricevendo InterruptedException (Java) o verificando isCancelled (Kotlin Coroutines).

Context Switch e il suo costo

Context switch (cambio di contesto) — operazione in cui l'OS salva lo stato del thread corrente (registri, PC, TLB) e carica lo stato salvato di un altro. Nei sistemi mobili (Linux + ART, XNU per iOS), un context switch richiede 1-10 microsecondi. Se un thread esegue un task in 100 microsecondi e il context switch ne richiede 5, allora il 5% del tempo viene sprecato. Per minimizzare i context switch, iOS utilizza GCD con work stealing, Android — pool con fixedThreadCount.

Thread in Android: da Thread a Coroutines

Android si è evoluto dal java.lang.Thread di basso livello alle moderne coroutine. Ogni livello di astrazione offre più possibilità con meno overhead. Thread è la classe base, ma la sua creazione diretta non è raccomandata: un nuovo thread non è gestito da un pool, è difficile da monitorare e annullare. AsyncTask (deprecato dall'API 30) era un passo avanti, ma soffriva di perdite di memoria e gestione scomoda delle configurazioni.

HandlerThread è una sottoclasse speciale di Thread con Looper, che può elaborare una coda di messaggi. Viene utilizzato per l'esecuzione sequenziale di task su un thread in background, ad esempio per scrivere dati in Room o file. HandlerThread viene creato chiamando start(), dopodiché tramite Handler(handlerThread.looper) è possibile inviare messaggi e Runnable. La chiamata handlerThread.quit() arresta il Looper e termina il thread.

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

class ThreadExample {

    // 1. Creazione diretta di Thread (non consigliata)
    fun directThread() {
        val thread = Thread(Runnable {
            Thread.sleep(1000)
            print("Direct thread executed")
        })
        thread.start()
    }

    // 2. HandlerThread per task sequenziali in background
    fun handlerThreadExample() {
        val handlerThread = HandlerThread("BackgroundQueue")
        handlerThread.start()

        val handler = Handler(handlerThread.looper)
        handler.post {
            // Esecuzione sequenziale su thread in background
            Thread.sleep(500)
            print("HandlerThread: task completato")
        }

        // Arresto del thread (eseguito quando i task sono completati)
        handlerThread.quitSafely()
    }

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

L'esempio ThreadExample mostra tutti e quattro i livelli di astrazione dei thread in Android. La creazione diretta di Thread è l'approccio più basso livello e meno efficiente. HandlerThread è utile per task sequenziali in background. Executors.newFixedThreadPool(4) crea un pool di 4 thread per l'esecuzione parallela di fino a 10 task. Kotlin Coroutines con Dispatchers.Default — un metodo moderno, efficiente e sicuro.

HandlerThread: task sequenziali in background

HandlerThread — una sottoclasse specializzata di Thread con Looper integrato e coda di messaggi. Viene creato chiamando start(), dopodiché tramite Handler(handlerThread.looper) è possibile inviare Runnable e messaggi. HandlerThread esegue i task rigorosamente in sequenza — il task successivo non inizia prima del completamento del precedente. È utile per scrivere dati in Room o file, dove l'ordine delle operazioni è critico. La chiamata quitSafely() arresta il Looper dopo il completamento del task corrente.

import Foundation

class ThreadManager {

    // 1. Thread (basso livello)
    func createThread() {
        let thread = Thread {
            // Il codice viene eseguito su un nuovo thread
            print("Current thread: \(Thread.current)")
        }
        thread.name = "com.app.worker"
        thread.qualityOfService = .utility
        thread.start()
    }

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

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

        // Barrier per la sincronizzazione della scrittura
        queue.async(flags: .barrier) {
            // Accesso esclusivo durante la scrittura
            print("Barrier write: exclusive access")
        }
    }

    // 3. OperationQueue con dipendenze
    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...")
        }

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

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

// Collezione thread-safe tramite 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)
        }
    }
}

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

class Counter {

    // 1. AtomicInteger — per contatori semplici
    private val atomicCount = AtomicInteger(0)
    fun incrementAtomic() = atomicCount.incrementAndGet()

    // 2. synchronized — per sezioni critiche
    @Synchronized
    fun synchronizedOperation() {
        // Un solo thread alla volta
        doWork()
    }

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

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

// Esempio di deadlock: A blocca B, B blocca 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") }
    }
}