Thread no desenvolvimento mobile — o que é, tipos e gerenciamento de threads

O que é Thread

Thread (linha de execução) — é uma sequência independente de instruções que o sistema operacional pode agendar em um núcleo da CPU. Cada processo (aplicativo) contém pelo menos uma thread — a Main Thread. Threads adicionais são criadas para execução paralela de tarefas. Cada thread tem sua própria pilha de programa (com variáveis locais), contador de programa (PC) e registradores. A memória heap é compartilhada entre todas as threads do processo.

Em sistemas operacionais móveis, as threads são agendadas por multitarefa preemptiva (preemptive multitasking): o SO pode interromper a execução de uma thread a qualquer momento e passar o controle para outra (context switch). A alternância de contexto é uma operação cara (1-10 microssegundos), pois requer salvar/restaurar registradores da CPU, atualizar o TLB e limpar caches. É por isso que um número excessivo de threads (centenas e milhares) prejudica o desempenho — o SO gasta mais tempo alternando do que executando.

Thread e processo — são conceitos diferentes. Processo é uma instância do aplicativo com memória virtual dedicada. Uma thread dentro do processo compartilha essa memória com outras threads. No Android, cada componente do aplicativo (Activity, Service, BroadcastReceiver) funciona em um processo, mas pode ser executado em threads diferentes. O aplicativo iOS também é um único processo com capacidade de criar threads adicionais via GCD ou Thread.

Ciclo de vida da thread: estados e transições

Cada thread em Java/Kotlin (Android) e NSThread (iOS) passa por cinco estados: New (criada), Runnable (pronta para execução), Running (executando na CPU), Blocked/Waiting (aguardando recurso ou notificação), Terminated (finalizada). As transições entre estados são gerenciadas pelo agendador do SO e por primitivas de sincronização. O desenvolvedor pode influenciar a prioridade da thread (Thread.setPriority()) e seu estado (sleep, join, interrupt).

No Android, a thread entra no estado Blocked ao tentar capturar um monitor ocupado (synchronized), chamar Object.wait() ou Thread.sleep(). No iOS — ao chamar NSCondition.wait(), pthread_cond_wait() ou dispatch_semaphore_wait(). No estado Blocked, a thread não consome CPU, mas ocupa memória (pilha). A thread pode ser interrompida (interrupted) de outra thread, recebendo InterruptedException (Java) ou isCancelled (Kotlin Coroutines).

Context Switch e seu custo

Context switch (alternância de contexto) — operação na qual o SO salva o estado da thread atual (registradores, PC, TLB) e carrega o estado salvo de outra. Em sistemas móveis (Linux + ART, XNU para iOS) o context switch leva de 1 a 10 microssegundos. Se uma thread executa uma tarefa em 100 microssegundos e o context switch leva 5, então 5% do tempo é desperdiçado. Para minimizar o context switch, o iOS usa GCD com work stealing, o Android — pools com fixedThreadCount.

Thread no Android: de Thread a Coroutines

Android evoluiu do java.lang.Thread de baixo nível para as coroutines modernas. Cada nível de abstração oferece mais capacidades com menos sobrecarga. Thread — classe básica, mas sua criação direta não é recomendada: a nova thread não é gerenciada por pool, é difícil de monitorar e cancelar. AsyncTask (deprecated desde API 30) foi um passo à frente, mas sofria de vazamentos de memória e tratamento inconveniente de configurações.

HandlerThread — uma subclasse especial de Thread com Looper, que pode processar uma fila de mensagens. É usado para execução sequencial de tarefas em uma thread de fundo, como escrever dados no Room ou em arquivos. HandlerThread é criado chamando start(), após o qual via Handler(handlerThread.looper) é possível enviar mensagens e Runnable. A chamada handlerThread.quit() para o Looper e finaliza a thread.

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

class ThreadExample {

    // 1. Criação direta de Thread (não recomendada)
    fun directThread() {
        val thread = Thread(Runnable {
            Thread.sleep(1000)
            print("Direct thread executed")
        })
        thread.start()
    }

    // 2. HandlerThread para tarefas sequenciais em segundo plano
    fun handlerThreadExample() {
        val handlerThread = HandlerThread("BackgroundQueue")
        handlerThread.start()

        val handler = Handler(handlerThread.looper)
        handler.post {
            // Execução sequencial em thread de fundo
            Thread.sleep(500)
            print("HandlerThread: tarefa concluída")
        }

        // Parar a thread (executado quando as tarefas terminam)
        handlerThread.quitSafely()
    }

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

O exemplo ThreadExample mostra todos os quatro níveis de abstração de threads no Android. A criação direta de Thread — a abordagem mais baixo nível e ineficiente. HandlerThread é útil para tarefas sequenciais em segundo plano. Executors.newFixedThreadPool(4) cria um pool de 4 threads para execução paralela de até 10 tarefas. Kotlin Coroutines com Dispatchers.Default — a maneira moderna, eficiente e segura.

HandlerThread: tarefas sequenciais em segundo plano

HandlerThread — uma subclasse especializada de Thread com Looper integrado e fila de mensagens. Ele é criado chamando start(), após o qual via Handler(handlerThread.looper) é possível enviar Runnable e mensagens. HandlerThread executa tarefas estritamente sequenciais — a próxima tarefa não começa até a anterior ser concluída. Isso é conveniente para escrever dados no Room ou em arquivos, onde a ordem das operações é crítica. A chamada quitSafely() para o Looper após a conclusão da tarefa atual.

import Foundation

class ThreadManager {

    // 1. Thread (baixo nível)
    func createThread() {
        let thread = Thread {
            // Código executado em nova thread
            print("Current thread: \(Thread.current)")
        }
        thread.name = "com.app.worker"
        thread.qualityOfService = .utility
        thread.start()
    }

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

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

        // Barrier para sincronização de escrita
        queue.async(flags: .barrier) {
            // Acesso exclusivo durante escrita
            print("Barrier write: exclusive access")
        }
    }

    // 3. OperationQueue com dependências
    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...")
        }

        // Dependências: download -> process -> save
        process.addDependency(download)
        save.addDependency(process)

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

// Coleção thread-safe 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)
        }
    }
}

// Sincronização em Android/Kotlin
import java.util.concurrent.atomic.AtomicInteger
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock

class Counter {

    // 1. AtomicInteger — para contadores simples
    private val atomicCount = AtomicInteger(0)
    fun incrementAtomic() = atomicCount.incrementAndGet()

    // 2. synchronized — para seções críticas
    @Synchronized
    fun synchronizedOperation() {
        // Apenas uma thread por vez
        doWork()
    }

    // 3. Mutex de coroutines — suspend-safe
    private val mutex = Mutex()
    suspend fun mutexOperation() {
        mutex.withLock {
            // código protegido — thread-safe
            doWork()
        }
    }

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

// Exemplo de Deadlock: A bloqueia B, B bloqueia 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") }
    }
}