Thread sa mobile development — ano ito, mga uri at pamamahala ng mga thread

Ano ang Thread

Thread (thread ng pagpapatupad) — isang independiyenteng pagkakasunod-sunod ng mga instruksiyon na maaaring i-schedule ng operating system sa isang CPU core. Ang bawat proseso (application) ay naglalaman ng hindi bababa sa isang thread — Main Thread. Ang mga karagdagang thread ay ginagawa para sa parallel na pagpapatupad ng mga gawain. Bawat thread ay may sariling program stack (na may mga lokal na variable), program counter (PC) at mga register. Ang heap memory ay ibinabahagi ng lahat ng thread ng proseso.

Sa mga mobile operating system, ang mga thread ay naka-schedule sa pamamagitan ng preemptive multitasking: maaaring i-interrupt ng operating system ang pagpapatupad ng isang thread anumang oras at ibigay ang kontrol sa iba (context switch). Ang paglipat ng konteksto ay isang mahal na operasyon (1–10 microsecond), dahil nangangailangan ito ng pag-save/pag-restore ng mga CPU register, pag-update ng TLB at paglilinis ng mga cache. Kaya naman ang labis na bilang ng mga thread (daan-daan at libo-libo) ay nagpapabagal ng performance — mas maraming oras ang ginugugol ng operating system sa paglipat kaysa sa pagpapatupad.

Thread at proseso ay magkaibang konsepto. Ang proseso ay isang instance ng application na may nakalaang virtual memory. Ang thread sa loob ng proseso ay nagbabahagi ng memorya na ito sa iba pang mga thread. Sa Android, bawat component ng application (Activity, Service, BroadcastReceiver) ay gumagana sa isang proseso, ngunit maaaring tumakbo sa iba't ibang thread. Ang iOS application ay isa ring proseso na may kakayahang gumawa ng mga karagdagang thread sa pamamagitan ng GCD o Thread.

Siklo ng buhay ng thread: mga estado at paglipat

Bawat thread sa Java/Kotlin (Android) at NSThread (iOS) ay dumadaan sa limang estado: New (gawa), Runnable (handa nang tumakbo), Running (tumatakbo sa CPU), Blocked/Waiting (naghihintay ng resource o notifikasyon), Terminated (tapos). Ang mga paglipat sa pagitan ng mga estado ay pinamamahalaan ng scheduler ng operating system at mga synchronization primitive. Maaaring maimpluwensyahan ng developer ang priority ng thread (Thread.setPriority()) at ang estado nito (sleep, join, interrupt).

Sa Android, ang thread ay pumapasok sa estado na Blocked kapag sinusubukang makuha ang isang abalang monitor (synchronized), pagtawag sa Object.wait() o Thread.sleep(). Sa iOS — kapag tumatawag ng NSCondition.wait(), pthread_cond_wait() o dispatch_semaphore_wait(). Sa estado na Blocked, ang thread ay hindi gumagamit ng CPU, ngunit sumasakop ng memorya (stack). Maaaring ma-interrupt (interrupted) ang thread mula sa ibang thread, sa pamamagitan ng pagtanggap ng InterruptedException (Java) o pag-check ng isCancelled (Kotlin Coroutines).

Context Switch at ang gastos nito

Context switch (paglipat ng konteksto) — isang operasyon kung saan ini-save ng operating system ang estado ng kasalukuyang thread (mga register, PC, TLB) at nilo-load ang na-save na estado ng isa pa. Sa mga mobile system (Linux + ART, XNU para sa iOS), ang context switch ay tumatagal ng 1–10 microsecond. Kung ang thread ay nagpapatupad ng gawain sa loob ng 100 microsecond at ang context switch ay tumatagal ng 5, 5% ng oras ang nasasayang. Upang mabawasan ang context switch, gumagamit ang iOS ng GCD na may work stealing, at Android — mga pool na may fixedThreadCount.

Thread sa Android: mula Thread hanggang Coroutines

Android ay umunlad mula sa mababang antas na java.lang.Thread hanggang sa modernong coroutine. Bawat antas ng abstraction ay nagbibigay ng mas maraming kakayahan na may mas kaunting overhead. Ang Thread ay ang base class, ngunit ang direktang paggawa nito ay hindi inirerekomenda: ang bagong thread ay hindi pinamamahalaan ng pool, mahirap itong i-monitor at i-cancel. Ang AsyncTask (deprecated mula API 30) ay isang hakbang pasulong, ngunit nagdusa sa memory leaks at hindi maginhawang pagproseso ng mga configuration.

Ang HandlerThread — espesyal na subclass ng Thread na may Looper, na maaaring magproseso ng queue ng mga mensahe. Ginagamit para sa sunod-sunod na pagpapatupad ng mga gawain sa background thread, halimbawa, pagsusulat ng data sa Room o mga file. Ang HandlerThread ay ginagawa sa pamamagitan ng tawag na start(), pagkatapos nito sa pamamagitan ng Handler(handlerThread.looper) maaaring magpadala ng mga mensahe at Runnable. Ang tawag na handlerThread.quit() ay humihinto sa Looper at tinatapos ang thread.

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

class ThreadExample {

    // 1. Direktang paggawa ng Thread (hindi inirerekomenda)
    fun directThread() {
        val thread = Thread(Runnable {
            Thread.sleep(1000)
            print("Direktang thread na naisagawa")
        })
        thread.start()
    }

    // 2. HandlerThread para sa sunod-sunod na mga background task
    fun handlerThreadExample() {
        val handlerThread = HandlerThread("BackgroundQueue")
        handlerThread.start()

        val handler = Handler(handlerThread.looper)
        handler.post {
            // Sunod-sunod na pagpapatupad sa background thread
            Thread.sleep(500)
            print("HandlerThread: tapos ang gawain")
        }

        // Paghinto ng thread (isinasagawa kapag tapos na ang mga gawain)
        handlerThread.quitSafely()
    }

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

Ang halimbawang ThreadExample ay nagpapakita ng lahat ng apat na antas ng abstraction ng thread sa Android. Ang direktang paggawa ng Thread ay ang pinakamababang antas at hindi epektibong pamamaraan. Ang HandlerThread ay kapaki-pakinabang para sa sunod-sunod na mga gawain sa background. Ang Executors.newFixedThreadPool(4) ay gumagawa ng pool ng 4 na thread para sa parallel na pagpapatupad ng hanggang 10 gawain. Ang Kotlin Coroutines na may Dispatchers.Default — moderno, epektibo at ligtas na paraan.

HandlerThread: sunod-sunod na mga background task

HandlerThread — isang espesyalisadong subclass ng Thread na may built-in na Looper at queue ng mga mensahe. Ginagawa sa pamamagitan ng tawag na start(), pagkatapos nito sa pamamagitan ng Handler(handlerThread.looper) maaaring magpadala ng Runnable at mga mensahe. Ang HandlerThread ay nagpapatupad ng mga gawain nang mahigpit na sunod-sunod — ang susunod na gawain ay hindi magsisimula hangga't hindi natatapos ang nauna. Ito ay maginhawa para sa pagsusulat ng data sa Room o mga file, kung saan mahalaga ang pagkakasunod-sunod ng mga operasyon. Ang tawag na quitSafely() ay humihinto sa Looper pagkatapos matapos ang kasalukuyang gawain.

import Foundation

class ThreadManager {

    // 1. Thread (mababang antas)
    func createThread() {
        let thread = Thread {
            // Ang code ay isinasagawa sa bagong thread
            print("Current thread: \(Thread.current)")
        }
        thread.name = "com.app.worker"
        thread.qualityOfService = .utility
        thread.start()
    }

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

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

        // Barrier para sa synchronization ng pagsulat
        queue.async(flags: .barrier) {
            // Eksklusibong access habang nagsusulat
            print("Barrier write: eksklusibong access")
        }
    }

    // 3. OperationQueue na may mga dependency
    func operationQueueExample() {
        let queue = OperationQueue()
        queue.maxConcurrentOperationCount = 2
        queue.qualityOfService = .background

        let download = BlockOperation {
            print("Nagda-download...")
        }
        let process = BlockOperation {
            print("Nagpoproseso...")
        }
        let save = BlockOperation {
            print("Nagse-save...")
        }

        // Mga dependency: download -> process -> save
        process.addDependency(download)
        save.addDependency(process)

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

// Thread-safe collection sa pamamagitan ng 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)
        }
    }
}

// Synchronization sa Android/Kotlin
import java.util.concurrent.atomic.AtomicInteger
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock

class Counter {

    // 1. AtomicInteger — para sa mga simpleng counter
    private val atomicCount = AtomicInteger(0)
    fun incrementAtomic() = atomicCount.incrementAndGet()

    // 2. synchronized — para sa mga kritikal na seksyon
    @Synchronized
    fun synchronizedOperation() {
        // Isang thread lamang sa bawat pagkakataon
        doWork()
    }

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

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

// Halimbawa ng deadlock: A humaharang sa B, B humaharang sa 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") }
    }
}