Thread trong phát triển di động — khái niệm, loại và quản lý luồng

Thread là gì

Thread (luồng thực thi) — là một chuỗi lệnh độc lập mà hệ điều hành có thể lập lịch trên một lõi CPU. Mỗi tiến trình (ứng dụng) chứa ít nhất một luồng — Main Thread. Các luồng bổ sung được tạo ra để thực thi song song các tác vụ. Mỗi luồng có ngăn xếp phần mềm riêng (với biến cục bộ), bộ đếm lệnh (PC) và thanh ghi. Bộ nhớ heap được chia sẻ cho tất cả các luồng của tiến trình.

Trong hệ điều hành di động, các luồng được lập lịch bằng đa nhiệm ưu tiên (preemptive multitasking): HĐH có thể ngắt luồng bất kỳ lúc nào và chuyển điều khiển cho luồng khác (context switch). Chuyển đổi ngữ cảnh là thao tác tốn kém (1-10 micro giây), vì nó yêu cầu lưu/phục hồi thanh ghi CPU, cập nhật TLB và xóa bộ nhớ đệm. Đó là lý do tại sao số lượng luồng quá nhiều (hàng trăm, hàng nghìn) làm giảm hiệu suất — HĐH dành nhiều thời gian cho chuyển đổi hơn là thực thi.

Luồng và tiến trình — là các khái niệm khác nhau. Tiến trình là một phiên bản ứng dụng với bộ nhớ ảo được cấp phát riêng. Luồng bên trong tiến trình chia sẻ bộ nhớ này với các luồng khác. Trong Android, mỗi thành phần ứng dụng (Activity, Service, BroadcastReceiver) hoạt động trong một tiến trình, nhưng có thể thực thi trên các luồng khác nhau. Ứng dụng iOS cũng là một tiến trình duy nhất với khả năng tạo các luồng bổ sung qua GCD hoặc Thread.

Vòng đời của luồng: trạng thái và chuyển đổi

Mỗi luồng trong Java/Kotlin (Android) và NSThread (iOS) trải qua năm trạng thái: New (được tạo), Runnable (sẵn sàng thực thi), Running (đang chạy trên CPU), Blocked/Waiting (chờ tài nguyên hoặc thông báo), Terminated (kết thúc). Các chuyển đổi giữa các trạng thái được quản lý bởi bộ lập lịch HĐH và các nguyên hàm đồng bộ hóa. Nhà phát triển có thể ảnh hưởng đến mức ưu tiên của luồng (Thread.setPriority()) và trạng thái của nó (sleep, join, interrupt).

Trong Android, một luồng chuyển sang trạng thái Blocked khi cố gắng chiếm monitor đang bận (synchronized), gọi Object.wait() hoặc Thread.sleep(). Trong iOS — khi gọi NSCondition.wait(), pthread_cond_wait() hoặc dispatch_semaphore_wait(). Ở trạng thái Blocked, luồng không tiêu thụ CPU nhưng chiếm bộ nhớ (ngăn xếp). Một luồng có thể bị ngắt (interrupted) từ luồng khác, nhận InterruptedException (Java) hoặc kiểm tra isCancelled (Kotlin Coroutines).

Context Switch và chi phí của nó

Context switch (chuyển đổi ngữ cảnh) — thao tác HĐH lưu trạng thái của luồng hiện tại (thanh ghi, PC, TLB) và tải trạng thái đã lưu của luồng khác. Trong hệ thống di động (Linux + ART, XNU cho iOS), context switch mất 1-10 micro giây. Nếu một luồng thực thi tác vụ trong 100 micro giây và context switch mất 5, thì 5% thời gian bị lãng phí. Để giảm thiểu context switch, iOS sử dụng GCD với work stealing, Android — các pool với fixedThreadCount.

Thread trong Android: từ Thread đến Coroutines

Android đã tiến hóa từ java.lang.Thread cấp thấp đến coroutines hiện đại. Mỗi mức trừu tượng mang lại nhiều khả năng hơn với chi phí thấp hơn. Thread là lớp cơ bản, nhưng việc tạo trực tiếp không được khuyến nghị: luồng mới không được quản lý bởi pool, khó giám sát và hủy bỏ. AsyncTask (không dùng nữa từ API 30) là một bước tiến, nhưng bị rò rỉ bộ nhớ và xử lý cấu hình bất tiện.

HandlerThread là một lớp con đặc biệt của Thread với Looper, có thể xử lý hàng đợi tin nhắn. Nó được sử dụng để thực thi tuần tự các tác vụ trên luồng nền, ví dụ ghi dữ liệu vào Room hoặc tệp tin. HandlerThread được tạo bằng cách gọi start(), sau đó qua Handler(handlerThread.looper) có thể gửi tin nhắn và Runnable. Gọi handlerThread.quit() dừng Looper và kết thúc luồng.

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

class ThreadExample {

    // 1. Tạo Thread trực tiếp (không khuyến nghị)
    fun directThread() {
        val thread = Thread(Runnable {
            Thread.sleep(1000)
            print("Direct thread executed")
        })
        thread.start()
    }

    // 2. HandlerThread cho tác vụ nền tuần tự
    fun handlerThreadExample() {
        val handlerThread = HandlerThread("BackgroundQueue")
        handlerThread.start()

        val handler = Handler(handlerThread.looper)
        handler.post {
            // Thực thi tuần tự trên luồng nền
            Thread.sleep(500)
            print("HandlerThread: tác vụ hoàn thành")
        }

        // Dừng luồng (thực thi khi tác vụ hoàn tất)
        handlerThread.quitSafely()
    }

    // 3. Executors — pool luồng
    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 — tiêu chuẩn hiện đại
    suspend fun coroutineExample() = kotlinx.coroutines.withContext(
        kotlinx.coroutines.Dispatchers.Default
    ) {
        print("Coroutine on thread: ${Thread.currentThread().getName()}")
    }
}

Ví dụ ThreadExample cho thấy cả bốn mức trừu tượng luồng trong Android. Tạo Thread trực tiếp là cách tiếp cận cấp thấp nhất và kém hiệu quả nhất. HandlerThread hữu ích cho các tác vụ tuần tự nền. Executors.newFixedThreadPool(4) tạo pool 4 luồng để thực thi song song tối đa 10 tác vụ. Kotlin Coroutines với Dispatchers.Default — cách hiện đại, hiệu quả và an toàn.

HandlerThread: tác vụ nền tuần tự

HandlerThread — lớp con chuyên biệt của Thread với Looper tích hợp và hàng đợi tin nhắn. Nó được tạo bằng cách gọi start(), sau đó qua Handler(handlerThread.looper) có thể gửi Runnable và tin nhắn. HandlerThread thực thi các tác vụ theo đúng thứ tự tuần tự — tác vụ tiếp theo không bắt đầu cho đến khi tác vụ trước kết thúc. Điều này thuận tiện cho việc ghi dữ liệu vào Room hoặc tệp tin, nơi thứ tự thao tác rất quan trọng. Gọi quitSafely() dừng Looper sau khi hoàn thành tác vụ hiện tại.

import Foundation

class ThreadManager {

    // 1. Thread (cấp thấp)
    func createThread() {
        let thread = Thread {
            // Mã được thực thi trên luồng mới
            print("Current thread: \(Thread.current)")
        }
        thread.name = "com.app.worker"
        thread.qualityOfService = .utility
        thread.start()
    }

    // 2. GCD — DispatchQueue
    func gcdExample() {
        // Hàng đợi song song
        let queue = DispatchQueue(label: "com.app.concurrent",
                                 qos: .utility,
                                 attributes: .concurrent)

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

        // Barrier để đồng bộ hóa ghi
        queue.async(flags: .barrier) {
            // Truy cập độc quyền trong khi ghi
            print("Barrier write: exclusive access")
        }
    }

    // 3. OperationQueue với phụ thuộc
    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...")
        }

        // Phụ thuộc: download -> process -> save
        process.addDependency(download)
        save.addDependency(process)

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

// Bộ sưu tập thread-safe qua 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)
        }
    }
}

// Đồng bộ hóa trong Android/Kotlin
import java.util.concurrent.atomic.AtomicInteger
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock

class Counter {

    // 1. AtomicInteger — cho bộ đếm đơn giản
    private val atomicCount = AtomicInteger(0)
    fun incrementAtomic() = atomicCount.incrementAndGet()

    // 2. synchronized — cho đoạn quan trọng
    @Synchronized
    fun synchronizedOperation() {
        // Chỉ một luồng tại một thời điểm
        doWork()
    }

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

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

// Ví dụ Deadlock: A khóa B, B khóa 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") }
    }
}