[Android 从零到一] 多线程与线程池：从 Thread 到高效并发

Thread {
    // 耗时操作
    val data = fetchDataFromNetwork()
    runOnUiThread {
        textView.text = data
    }
}.start()

val handler = Handler(Looper.getMainLooper())

Thread {
    val result = doHeavyWork()
    handler.post {
        // 回到主线程更新 UI
        textView.text = result
    }
}.start()

// 固定大小线程池 —— 最常用的选择
val fixedPool = Executors.newFixedThreadPool(4)

// 缓存线程池 —— 适合大量短时任务
val cachedPool = Executors.newCachedThreadPool()

// 单线程池 —— 保证任务顺序执行
val singlePool = Executors.newSingleThreadExecutor()

// 定时线程池 —— 周期性任务
val scheduledPool = Executors.newScheduledThreadPool(2)

val executor = Executors.newFixedThreadPool(4)

// 提交任务
executor.execute {
    val bitmap = downloadImage(url)
    handler.post { imageView.setImageBitmap(bitmap) }
}

// 提交有返回值的任务
val future: Future<String> = executor.submit(Callable {
    fetchDataFromServer()
})
// 获取结果（会阻塞当前线程）
val result = future.get()

// CPU 密集型：线程数 ≈ CPU 核心数
val cpuThreads = Runtime.getRuntime().availableProcessors()

// IO 密集型：线程数可以多一些（网络、文件操作等待时间长）
val ioThreads = cpuThreads * 2

val pool = ThreadPoolExecutor(
    2,                          // corePoolSize：核心线程数（常驻）
    4,                          // maximumPoolSize：最大线程数
    60L, TimeUnit.SECONDS,      // 非核心线程空闲存活时间
    LinkedBlockingQueue(100),   // 任务队列
    Executors.defaultThreadFactory(),
    ThreadPoolExecutor.CallerRunsPolicy()  // 拒绝策略
)

提交任务
  ↓
核心线程是否已满？── 否 → 创建核心线程执行
  ↓ 是
队列是否已满？── 否 → 放入队列等待
  ↓ 是
是否达到最大线程数？── 否 → 创建非核心线程执行
  ↓ 是
执行拒绝策略

val executor = Executors.newFixedThreadPool(4)

fun loadImages(urls: List<String>, callback: (String, Bitmap) -> Unit) {
    val handler = Handler(Looper.getMainLooper())
    urls.forEach { url ->
        executor.execute {
            val bitmap = downloadBitmap(url)
            handler.post { callback(url, bitmap) }
        }
    }
}

// 单线程池保证写入顺序
val dbExecutor = Executors.newSingleThreadExecutor()

fun saveUser(user: User) {
    dbExecutor.execute {
        database.userDao().insert(user)
    }
}

fun saveLog(log: LogEntry) {
    dbExecutor.execute {
        database.logDao().insert(log)
    }
}

val scheduler = Executors.newScheduledThreadPool(1)

// 每小时清理一次过期缓存
scheduler.scheduleAtFixedRate({
    clearExpiredCache()
}, 0, 1, TimeUnit.HOURS)

// 协程内部依然可以使用线程池
val ioDispatcher = Executors.newFixedThreadPool(4).asCoroutineDispatcher()

viewModelScope.launch {
    val result = withContext(ioDispatcher) {
        fetchData()
    }
    updateUI(result)
}

var counter = 0

// 多线程同时执行 counter++，结果可能不对
fun increment() {
    counter++  // 非原子操作！
}

// 方案一：synchronized
@Synchronized
fun increment() {
    counter++
}

// 方案二：原子变量
val counter = AtomicInteger(0)
fun increment() {
    counter.incrementAndGet()
}

// 方案三：volatile（保证可见性，不保证原子性）
@Volatile
var flag = false

class MyActivity : AppCompatActivity() {
    private val executor = Executors.newFixedThreadPool(4)

    override fun onDestroy() {
        super.onDestroy()
        // 停止接收新任务，等待已提交任务完成
        executor.shutdown()
        // 或者立即中断所有线程
        // executor.shutdownNow()
    }
}

class MyViewModel : ViewModel() {
    private val executor = Executors.newFixedThreadPool(4)

    override fun onCleared() {
        super.onCleared()
        executor.shutdown()
    }

    fun loadData() {
        executor.execute {
            val data = repository.fetch()
            _result.postValue(data)
        }
    }
}