Thread dalam pengembangan mobile — apa itu, jenis dan pengelolaan thread

Apa itu Thread

Thread (utas eksekusi) — rangkaian instruksi independen yang dapat dijadwalkan sistem operasi pada inti CPU. Setiap proses (aplikasi) berisi setidaknya satu thread — Main Thread. Thread tambahan dibuat untuk eksekusi paralel tugas. Setiap thread memiliki stack program sendiri (dengan variabel lokal), program counter (PC) dan register. Memori heap dibagi oleh semua thread dari proses tersebut.

Pada sistem operasi mobile, thread dijadwalkan dengan multitasking preemptif (preemptive multitasking): sistem operasi dapat menginterupsi eksekusi thread kapan saja dan menyerahkan kendali ke thread lain (context switch). Pengalihan konteks adalah operasi yang mahal (1–10 mikrodetik), karena memerlukan penyimpanan/pemulihan register CPU, pembaruan TLB dan pembersihan cache. Justru karena itulah jumlah thread yang berlebihan (ratusan dan ribuan) memperburuk kinerja — sistem operasi menghabiskan lebih banyak waktu untuk beralih daripada mengeksekusi.

Thread dan proses adalah konsep yang berbeda. Proses adalah instance aplikasi dengan memori virtual khusus. Thread di dalam proses berbagi memori ini dengan thread lain. Di Android, setiap komponen aplikasi (Activity, Service, BroadcastReceiver) bekerja dalam satu proses, tetapi dapat dieksekusi di thread yang berbeda. Aplikasi iOS juga merupakan satu proses dengan kemampuan membuat thread tambahan melalui GCD atau Thread.

Siklus hidup thread: status dan transisi

Setiap thread di Java/Kotlin (Android) dan NSThread (iOS) melewati lima status: New (dibuat), Runnable (siap dieksekusi), Running (sedang dieksekusi di CPU), Blocked/Waiting (menunggu sumber daya atau notifikasi), Terminated (selesai). Transisi antar status dikelola oleh penjadwal sistem operasi dan primitif sinkronisasi. Pengembang dapat memengaruhi prioritas thread (Thread.setPriority()) dan statusnya (sleep, join, interrupt).

Di Android, thread masuk ke status Blocked saat mencoba menguasai monitor yang sibuk (synchronized), memanggil Object.wait() atau Thread.sleep(). Di iOS — saat memanggil NSCondition.wait(), pthread_cond_wait() atau dispatch_semaphore_wait(). Dalam status Blocked, thread tidak mengonsumsi CPU, tetapi memakai memori (stack). Thread dapat diinterupsi (interrupted) dari thread lain, dengan menerima InterruptedException (Java) atau memeriksa isCancelled (Kotlin Coroutines).

Context Switch dan biayanya

Context switch (pengalihan konteks) — operasi di mana sistem operasi menyimpan status thread saat ini (register, PC, TLB) dan memuat status tersimpan dari thread lain. Pada sistem mobile (Linux + ART, XNU untuk iOS), context switch berlangsung 1–10 mikrodetik. Jika thread mengeksekusi tugas dalam 100 mikrodetik dan context switch memakan 5, maka 5% waktu terbuang. Untuk meminimalkan context switch, iOS menggunakan GCD dengan work stealing, dan Android menggunakan pool dengan fixedThreadCount.

Thread di Android: dari Thread hingga Coroutines

Android berevolusi dari java.lang.Thread tingkat rendah hingga coroutine modern. Setiap tingkat abstraksi memberikan lebih banyak kemampuan dengan overhead lebih kecil. Thread adalah kelas dasar, tetapi pembuatan langsung tidak disarankan: thread baru tidak dikelola oleh pool, sulit dipantau dan dibatalkan. AsyncTask (deprecated sejak API 30) adalah langkah maju, tetapi menderita kebocoran memori dan penanganan konfigurasi yang tidak nyaman.

HandlerThread — subkelas khusus Thread dengan Looper yang dapat memproses antrian pesan. Digunakan untuk eksekusi berurutan tugas di thread latar belakang, misalnya menulis data ke Room atau file. HandlerThread dibuat dengan panggilan start(), setelah itu melalui Handler(handlerThread.looper) dapat dikirim pesan dan Runnable. Panggilan handlerThread.quit() menghentikan Looper dan mengakhiri thread.

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

class ThreadExample {

    // 1. Pembuatan langsung Thread (tidak disarankan)
    fun directThread() {
        val thread = Thread(Runnable {
            Thread.sleep(1000)
            print("Thread langsung dieksekusi")
        })
        thread.start()
    }

    // 2. HandlerThread untuk tugas latar belakang berurutan
    fun handlerThreadExample() {
        val handlerThread = HandlerThread("BackgroundQueue")
        handlerThread.start()

        val handler = Handler(handlerThread.looper)
        handler.post {
            // Eksekusi berurutan di thread latar belakang
            Thread.sleep(500)
            print("HandlerThread: tugas dieksekusi")
        }

        // Menghentikan thread (dieksekusi ketika tugas selesai)
        handlerThread.quitSafely()
    }

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

Contoh ThreadExample menunjukkan keempat tingkat abstraksi thread di Android. Pembuatan langsung Thread adalah pendekatan paling rendah dan tidak efisien. HandlerThread berguna untuk tugas berurutan di latar belakang. Executors.newFixedThreadPool(4) membuat pool 4 thread untuk eksekusi paralel hingga 10 tugas. Kotlin Coroutines dengan Dispatchers.Default — cara yang modern, efisien dan aman.

HandlerThread: tugas latar belakang berurutan

HandlerThread — subkelas khusus Thread dengan Looper bawaan dan antrian pesan. Dibuat dengan panggilan start(), setelah itu melalui Handler(handlerThread.looper) dapat dikirim Runnable dan pesan. HandlerThread mengeksekusi tugas secara ketat berurutan — tugas berikutnya tidak dimulai sebelum tugas sebelumnya selesai. Ini nyaman untuk menulis data ke Room atau file, di mana urutan operasi sangat penting. Panggilan quitSafely() menghentikan Looper setelah tugas saat ini selesai.

import Foundation

class ThreadManager {

    // 1. Thread (tingkat rendah)
    func createThread() {
        let thread = Thread {
            // Kode dieksekusi di thread baru
            print("Current thread: \(Thread.current)")
        }
        thread.name = "com.app.worker"
        thread.qualityOfService = .utility
        thread.start()
    }

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

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

        // Barrier untuk sinkronisasi penulisan
        queue.async(flags: .barrier) {
            // Akses eksklusif selama penulisan
            print("Barrier write: akses eksklusif")
        }
    }

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

        let download = BlockOperation {
            print("Mengunduh...")
        }
        let process = BlockOperation {
            print("Memproses...")
        }
        let save = BlockOperation {
            print("Menyimpan...")
        }

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

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

// Koleksi thread-safe melalui 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)
        }
    }
}

// Sinkronisasi di Android/Kotlin
import java.util.concurrent.atomic.AtomicInteger
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock

class Counter {

    // 1. AtomicInteger — untuk penghitung sederhana
    private val atomicCount = AtomicInteger(0)
    fun incrementAtomic() = atomicCount.incrementAndGet()

    // 2. synchronized — untuk bagian kritis
    @Synchronized
    fun synchronizedOperation() {
        // Hanya satu thread pada satu waktu
        doWork()
    }

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

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

// Contoh deadlock: A memblokir B, B memblokir 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") }
    }
}