Thread ในการพัฒนา Mobile — คืออะไร ประเภท และการจัดการเธรด

Thread คืออะไร

Thread (เธรดการทำงาน) — คือลำดับคำสั่งอิสระที่ระบบปฏิบัติการสามารถจัดตารางเวลาบนแกน CPU แต่ละกระบวนการ (แอปพลิเคชัน) มีอย่างน้อยหนึ่งเธรด — Main Thread เธรดเพิ่มเติมถูกสร้างขึ้นสำหรับการทำงานแบบขนานของงาน แต่ละเธรดมีสแต็คซอฟต์แวร์ของตัวเอง (พร้อมตัวแปรท้องถิ่น), ตัวนับคำสั่ง (PC) และรีจิสเตอร์ หน่วยความจำฮีป (heap) ถูกแชร์ระหว่างเธรดทั้งหมดของกระบวนการ

ในระบบปฏิบัติการมือถือ เธรดถูกจัดตารางเวลาด้วยการทำงานหลายอย่างแบบยึด抢先 (preemptive multitasking): ระบบปฏิบัติการสามารถขัดจังหวะการทำงานของเธรดได้ทุกเมื่อและโอนการควบคุมไปยังเธรดอื่น (context switch) การสลับบริบทเป็นการดำเนินการที่แพง (1-10 ไมโครวินาที) เนื่องจากต้องบันทึก/กู้คืนรีจิสเตอร์ CPU อัปเดต TLB และล้างแคช ดังนั้นจำนวนเธรดที่มากเกินไป (ร้อยหรือพัน) ทำให้ประสิทธิภาพลดลง — ระบบปฏิบัติการใช้เวลาในการสลับมากกว่าการทำงาน

เธรดและกระบวนการ — เป็นแนวคิดที่แตกต่างกัน กระบวนการคืออินสแตนซ์ของแอปพลิเคชันที่มีหน่วยความจำเสมือนเฉพาะ เธรดภายในกระบวนการแชร์หน่วยความจำนี้กับเธรดอื่น ใน Android แต่ละคอมโพเนนต์ของแอปพลิเคชัน (Activity, Service, BroadcastReceiver) ทำงานในกระบวนการเดียว แต่สามารถดำเนินการบนเธรดที่แตกต่างกัน แอปพลิเคชัน iOS ก็เป็นกระบวนการเดียวที่มีความสามารถในการสร้างเธรดเพิ่มเติมผ่าน GCD หรือ Thread

วงจรชีวิตของเธรด: สถานะและการเปลี่ยนผ่าน

แต่ละเธรด ใน Java/Kotlin (Android) และ NSThread (iOS) ผ่านห้าสถานะ: New (สร้าง), Runnable (พร้อมทำงาน), Running (กำลังทำงานบน CPU), Blocked/Waiting (รอทรัพยากรหรือการแจ้งเตือน), Terminated (สิ้นสุด) การเปลี่ยนผ่านระหว่างสถานะถูกจัดการโดยตัวจัดตารางเวลาของระบบปฏิบัติการและไพรมิทีฟการซิงโครไนซ์ นักพัฒนาสามารถมีอิทธิพลต่อลำดับความสำคัญของเธรด (Thread.setPriority()) และสถานะของมัน (sleep, join, interrupt)

ใน Android เธรดเปลี่ยนไปยังสถานะ Blocked เมื่อพยายามยึดมอนิเตอร์ที่ถูกใช้งาน (synchronized), เรียก Object.wait() หรือ Thread.sleep() ใน iOS — เมื่อเรียก NSCondition.wait(), pthread_cond_wait() หรือ dispatch_semaphore_wait() ในสถานะ Blocked เธรดไม่กิน CPU แต่กินหน่วยความจำ (สแต็ค) เธรดสามารถถูกขัดจังหวะ (interrupted) จากเธรดอื่น โดยได้รับ InterruptedException (Java) หรือตรวจสอบ isCancelled (Kotlin Coroutines)

Context Switch และต้นทุนของมัน

Context switch (การสลับบริบท) — การดำเนินการที่ระบบปฏิบัติการบันทึกสถานะของเธรดปัจจุบัน (รีจิสเตอร์, PC, TLB) และโหลดสถานะที่บันทึกไว้ของเธรดอื่น ในระบบมือถือ (Linux + ART, XNU สำหรับ iOS) context switch ใช้เวลา 1-10 ไมโครวินาที ถ้าเธรดทำงานเสร็จใน 100 ไมโครวินาทีและ context switch ใช้ 5 ไมโครวินาที แสดงว่าเสียเวลา 5% เพื่อลด context switch iOS ใช้ GCD แบบ work stealing, Android ใช้พูลแบบ fixedThreadCount

Thread ใน Android: จาก Thread สู่ Coroutines

Android ได้วิวัฒนาการจาก java.lang.Thread ระดับต่ำสู่ coroutines สมัยใหม่ แต่ละระดับของนามธรรมให้ความสามารถมากขึ้นด้วยค่าใช้จ่ายที่น้อยลง Thread เป็นคลาสพื้นฐาน แต่การสร้างโดยตรงไม่แนะนำ: เธรดใหม่ไม่ถูกจัดการโดยพูล ยากต่อการตรวจสอบและยกเลิก AsyncTask (เลิกใช้งานตั้งแต่ API 30) เป็นก้าวไปข้างหน้า แต่ประสบปัญหาการรั่วไหลของหน่วยความจำและการจัดการคอนฟิกูเรชันที่ไม่สะดวก

HandlerThread เป็นคลาสย่อยพิเศษของ Thread ที่มี Looper ซึ่งสามารถประมวลผลคิวข้อความ ถูกใช้สำหรับการทำงานตามลำดับของงานบนเธรดพื้นหลัง เช่น การเขียนข้อมูลลงใน Room หรือไฟล์ HandlerThread ถูกสร้างโดยเรียก start() จากนั้นผ่าน Handler(handlerThread.looper) สามารถส่งข้อความและ Runnable การเรียก handlerThread.quit() หยุด Looper และสิ้นสุดเธรด

// Android: Thread, HandlerThread และ Executors
import android.os.Handler
import android.os.HandlerThread
import java.util.concurrent.Executors

class ThreadExample {

    // 1. การสร้าง Thread โดยตรง (ไม่แนะนำ)
    fun directThread() {
        val thread = Thread(Runnable {
            Thread.sleep(1000)
            print("Direct thread executed")
        })
        thread.start()
    }

    // 2. HandlerThread สำหรับงานพื้นหลังแบบลำดับ
    fun handlerThreadExample() {
        val handlerThread = HandlerThread("BackgroundQueue")
        handlerThread.start()

        val handler = Handler(handlerThread.looper)
        handler.post {
            // การทำงานตามลำดับบนเธรดพื้นหลัง
            Thread.sleep(500)
            print("HandlerThread: งานเสร็จสมบูรณ์")
        }

        // หยุดเธรด (ทำงานเมื่องานเสร็จ)
        handlerThread.quitSafely()
    }

    // 3. Executors — พูลเธรด
    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 — มาตรฐานสมัยใหม่
    suspend fun coroutineExample() = kotlinx.coroutines.withContext(
        kotlinx.coroutines.Dispatchers.Default
    ) {
        print("Coroutine on thread: ${Thread.currentThread().getName()}")
    }
}

ตัวอย่าง ThreadExample แสดงนามธรรมเธรดทั้งสี่ระดับใน Android การสร้าง Thread โดยตรงเป็นวิธีระดับต่ำสุดและมีประสิทธิภาพน้อยที่สุด HandlerThread มีประโยชน์สำหรับงานลำดับพื้นหลัง Executors.newFixedThreadPool(4) สร้างพูล 4 เธรดสำหรับการทำงานแบบขนานสูงสุด 10 งาน Kotlin Coroutines กับ Dispatchers.Default — วิธีที่ทันสมัย มีประสิทธิภาพ และปลอดภัย

HandlerThread: งานพื้นหลังแบบลำดับ

HandlerThread — คลาสย่อยเฉพาะของ Thread ที่มี Looper ในตัวและคิวข้อความ มันถูกสร้างโดยเรียก start() จากนั้นผ่าน Handler(handlerThread.looper) สามารถส่ง Runnable และข้อความ HandlerThread ทำงานตามลำดับอย่างเคร่งครัด — งานถัดไปจะไม่เริ่มจนกว่างานก่อนหน้าจะเสร็จ สะดวกสำหรับการเขียนข้อมูลลงใน Room หรือไฟล์ที่ลำดับการดำเนินการสำคัญ การเรียก quitSafely() หยุด Looper หลังจากงานปัจจุบันเสร็จ

import Foundation

class ThreadManager {

    // 1. Thread (ระดับต่ำ)
    func createThread() {
        let thread = Thread {
            // โค้ดทำงานบนเธรดใหม่
            print("Current thread: \(Thread.current)")
        }
        thread.name = "com.app.worker"
        thread.qualityOfService = .utility
        thread.start()
    }

    // 2. GCD — DispatchQueue
    func gcdExample() {
        // คิวขนาน
        let queue = DispatchQueue(label: "com.app.concurrent",
                                 qos: .utility,
                                 attributes: .concurrent)

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

        // Barrier สำหรับการซิงโครไนซ์การเขียน
        queue.async(flags: .barrier) {
            // การเข้าถึงเฉพาะระหว่างการเขียน
            print("Barrier write: exclusive access")
        }
    }

    // 3. OperationQueue พร้อมการพึ่งพา
    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...")
        }

        // การพึ่งพา: download -> process -> save
        process.addDependency(download)
        save.addDependency(process)

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

// คอลเลกชัน thread-safe ผ่าน 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)
        }
    }
}

// การซิงโครไนซ์ใน Android/Kotlin
import java.util.concurrent.atomic.AtomicInteger
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock

class Counter {

    // 1. AtomicInteger — สำหรับตัวนับอย่างง่าย
    private val atomicCount = AtomicInteger(0)
    fun incrementAtomic() = atomicCount.incrementAndGet()

    // 2. synchronized — สำหรับส่วนวิกฤต
    @Synchronized
    fun synchronizedOperation() {
        // ทีละหนึ่งเธรดเท่านั้น
        doWork()
    }

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

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

// ตัวอย่าง Deadlock: A ล็อค B, B ล็อค 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") }
    }
}