移动开发中的线程（Thread）——是什么、种类与线程管理

什么是线程（Thread）

Thread（执行线程）是操作系统可以在 CPU 内核上调度的一组独立指令序列。每个进程（应用程序）至少包含一个线程——主线程（Main Thread）。额外的线程用于并行执行任务。每个线程都有自己的程序堆栈（包含局部变量）、程序计数器（PC）和寄存器。堆内存由进程的所有线程共享。

在移动操作系统中，线程通过抢占式多任务处理（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 中，当线程尝试获取被占用的监视器（synchronized）、调用 Object.wait() 或 Thread.sleep() 时，会进入 Blocked 状态。在 iOS 中——调用 NSCondition.wait()、pthread_cond_wait() 或 dispatch_semaphore_wait() 时。在 Blocked 状态下，线程不消耗 CPU，但占用内存（堆栈）。线程可以从另一个线程被中断（interrupted），接收 InterruptedException（Java）或检查 isCancelled（Kotlin Coroutines）。

上下文切换及其成本

Context switch（上下文切换）是操作系统保存当前线程状态（寄存器、PC、TLB）并加载另一个线程已保存状态的操作。在移动系统（Linux + ART，iOS 使用 XNU）中，上下文切换需要 1–10 微秒。如果线程用 100 微秒执行任务，而上下文切换需要 5 微秒，那么 5% 的时间就被浪费了。为了最小化上下文切换，iOS 使用带 work stealing 的 GCD，Android 使用带 fixedThreadCount 的线程池。

Android 中的线程：从 Thread 到 Coroutines

Android 从底层的 java.lang.Thread 发展到现代的协程。每一层抽象都以更少的开销提供更多能力。Thread 是基础类，但不建议直接创建它：新线程不受池管理，难以监控和取消。AsyncTask（从 API 30 起已弃用）是一个进步，但存在内存泄漏和配置处理不便的问题。

HandlerThread 是带有 Looper 的特殊 Thread 子类，可以处理消息队列。它用于在后台线程上顺序执行任务，例如将数据写入 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("直接线程已执行")
        })
        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 个任务。使用 Dispatchers.Default 的 Kotlin Coroutines 是现代化、高效且安全的方式。

HandlerThread：顺序后台任务

HandlerThread 是带有内置 Looper 和消息队列的 Thread 专用子类。通过调用 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 异步任务")
        }

        // 用于写入同步的 Barrier
        queue.async(flags: .barrier) {
            // 写入期间的独占访问
            print("Barrier write：独占访问")
        }
    }

    // 3. 带依赖的 OperationQueue
    func operationQueueExample() {
        let queue = OperationQueue()
        queue.maxConcurrentOperationCount = 2
        queue.qualityOfService = .background

        let download = BlockOperation {
            print("正在下载...")
        }
        let process = BlockOperation {
            print("正在处理...")
        }
        let save = BlockOperation {
            print("正在保存...")
        }

        // 依赖：download -> process -> save
        process.addDependency(download)
        save.addDependency(process)

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

// 通过 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 —— suspend-safe
    private val mutex = Mutex()
    suspend fun mutexOperation() {
        mutex.withLock {
            // protected code —— 线程安全
            doWork()
        }
    }

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

// 死锁示例：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") }
    }
}