Android 线程详解

在Android开发中，线程是处理并发任务的核心机制，直接影响应用的性能和用户体验。Android的线程模型基于Java线程，但针对移动场景做了特殊优化（如UI线程限制、Handler机制等）。以下从基础概念、核心组件、使用场景到最佳实践进行详细解析：

一、线程基础概念

线程是进程内的执行单元，一个进程（应用）可包含多个线程，共享进程资源但独立执行。Android中线程分为两类：

1. 主线程（Main Thread / UI Thread）

定义：应用启动时系统自动创建的线程，负责处理UI渲染、用户交互（如点击事件）、生命周期回调等。
核心限制 ：
- 必须避免耗时操作 （如网络请求、大数据计算），否则会导致UI卡顿，超过阈值（输入事件5秒未响应，BroadcastReceiver 10秒未完成）会触发ANR（应用无响应）。
- 是唯一能更新UI的线程 （子线程直接更新UI会抛出异常，如CalledFromWrongThreadException）。

2. 子线程（Worker Thread）

定义：开发者手动创建的线程，用于执行耗时操作，避免阻塞主线程。
核心作用：处理网络请求、数据库读写、文件IO、复杂计算等耗时任务。
限制：不能直接更新UI，需通过特定机制（如Handler）通知主线程更新。

二、线程创建与启动方式

Android中创建线程的方式与Java一致，核心有3种：

1. 继承Thread类

重写run()方法定义线程执行逻辑，调用start()启动线程（不可直接调用run()，否则会在当前线程同步执行）。

kotlin 复制代码

class MyThread : Thread() {
    override fun run() {
        // 耗时操作（如网络请求）
        val result = fetchDataFromNetwork()
        // 不能直接更新UI，需通过Handler等机制
    }
}

// 启动线程
val thread = MyThread()
thread.start() // 启动新线程执行run()

2. 实现Runnable接口

将任务逻辑封装在Runnable中，作为参数传入Thread，更灵活（可避免单继承限制）。

kotlin 复制代码

val runnable = Runnable {
    // 耗时操作
    val result = processLargeData()
}

// 启动线程
val thread = Thread(runnable)
thread.start()

3. 使用线程池（Executor）

频繁创建/销毁线程会消耗资源，线程池通过复用线程提高效率，是推荐的线程管理方式。

Android中常用ThreadPoolExecutor或Executors工具类创建线程池：

kotlin 复制代码

// 1. 手动配置线程池（推荐，可自定义参数）
val threadPool = ThreadPoolExecutor(
    corePoolSize = 2, // 核心线程数（始终存活）
    maximumPoolSize = 4, // 最大线程数
    keepAliveTime = 30, // 非核心线程空闲超时时间
    TimeUnit.SECONDS,
    workQueue = LinkedBlockingQueue() // 任务队列
)

// 2. 提交任务
threadPool.execute {
    // 耗时操作
}

// 3. 任务完成后关闭线程池（如Activity销毁时）
threadPool.shutdown()

常用预设线程池 （通过Executors创建，适合简单场景）：

Executors.newCachedThreadPool()：缓存线程池（无核心线程，任务来了创建线程，空闲60秒销毁），适合短期任务。
Executors.newFixedThreadPool(n)：固定大小线程池，适合长期任务。
Executors.newSingleThreadExecutor()：单线程池（任务串行执行），适合有序任务。

三、线程通信核心机制：Handler-Looper-MessageQueue

Android中线程间通信（尤其是子线程向主线程发送UI更新指令）的核心是Handler机制 ，由Handler、Looper、MessageQueue三者配合实现。

1. 核心组件分工

MessageQueue ：消息队列，存储Message或Runnable，按时间顺序排列。
Looper ：线程的"消息循环器"，不断从MessageQueue中取出消息并处理，一个线程只能有一个Looper。
Handler ：消息发送者和处理器，通过sendMessage()向MessageQueue发送消息，并重写handleMessage()处理消息。

2. 工作流程

主线程初始化 ：应用启动时，系统自动为主线程创建Looper和MessageQueue，并启动消息循环（Looper.loop()）。
子线程发送消息 ：子线程通过Handler的sendMessage()发送Message到主线程的MessageQueue。
主线程处理消息 ：Looper从队列中取出消息，交给Handler的handleMessage()处理（此时已在主线程，可安全更新UI）。

3. 示例：子线程通过Handler更新UI

kotlin 复制代码

// 1. 在主线程创建Handler（关联主线程Looper）
val uiHandler = object : Handler(Looper.getMainLooper()) {
    override fun handleMessage(msg: Message) {
        super.handleMessage(msg)
        // 此方法在主线程执行，可更新UI
        when (msg.what) {
            1 -> textView.text = "数据加载完成：${msg.obj}"
        }
    }
}

// 2. 子线程执行耗时操作并发送消息
Thread {
    val data = fetchData() // 耗时操作
    // 创建消息
    val msg = Message.obtain()
    msg.what = 1 // 消息标识
    msg.obj = data // 传递数据
    uiHandler.sendMessage(msg) // 发送到主线程
}.start()

四、子线程更新UI的其他方式

除了Handler，Android还提供了更简洁的UI更新方式：

1. Activity.runOnUiThread()

直接在子线程中调用，内部通过Handler实现，简化代码：

kotlin 复制代码

Thread {
    val result = calculate() // 耗时操作
    // 切换到主线程更新UI
    runOnUiThread {
        textView.text = "计算结果：$result"
    }
}.start()

2. View.post(Runnable)

通过View的post()方法，将任务提交到主线程执行：

kotlin 复制代码

Thread {
    val image = loadImage() // 耗时加载图片
    imageView.post {
        imageView.setImageBitmap(image) // 更新UI
    }
}.start()

3. AsyncTask（已过时，了解即可）

Android早期提供的异步任务类，封装了线程池和Handler，但因生命周期管理问题已被废弃（API 30+标记为过时），推荐用协程或线程池+Handler替代。

4. Kotlin协程（推荐）

Kotlin协程是轻量级线程，通过Dispatchers.Main直接切换到主线程，代码更简洁：

kotlin 复制代码

// 依赖：implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.4'
lifecycleScope.launch(Dispatchers.IO) { // 子线程执行
    val data = fetchData() // 耗时操作
    withContext(Dispatchers.Main) { // 切换到主线程
        textView.text = data // 更新UI
    }
}

五、线程同步与安全

多线程并发访问共享资源时，可能导致数据不一致（如竞态条件），需通过同步机制保证线程安全。

1. synchronized关键字

修饰方法或代码块，保证同一时间只有一个线程执行：

kotlin 复制代码

// 同步方法
@Synchronized
fun updateCount() {
    count++
}

// 同步代码块
fun updateCount() {
    synchronized(this) { // 锁对象（通常用共享资源的对象）
        count++
    }
}

2. Lock接口

比synchronized更灵活（支持超时、中断），常用实现类ReentrantLock：

kotlin 复制代码

private val lock = ReentrantLock()

fun updateCount() {
    lock.lock() // 获取锁
    try {
        count++
    } finally {
        lock.unlock() // 必须释放锁
    }
}

3. 原子类（Atomic）

Java提供的线程安全基础类型（如AtomicInteger、AtomicBoolean），通过CAS（Compare-And-Swap）操作保证原子性，无需加锁：

kotlin 复制代码

private val atomicCount = AtomicInteger(0)

fun updateCount() {
    atomicCount.incrementAndGet() // 原子自增，线程安全
}

六、特殊线程类型

1. HandlerThread

一种带Looper的线程，可创建关联该线程的Handler，实现线程内的消息循环（适合需要持续处理任务的场景，如后台服务）：

kotlin 复制代码

// 创建HandlerThread
val handlerThread = HandlerThread("MyHandlerThread")
handlerThread.start() // 启动线程，初始化Looper

// 创建关联该线程的Handler
val backgroundHandler = Handler(handlerThread.looper) { msg ->
    // 此方法在HandlerThread中执行（子线程）
    when (msg.what) {
        1 -> processTask(msg.obj) // 处理任务
    }
    true
}

// 发送任务到HandlerThread
backgroundHandler.sendEmptyMessage(1)

// 退出时释放资源
handlerThread.quit()

2. IntentService（已过时）

专为后台任务设计的Service，内部封装HandlerThread，任务执行完自动停止。已被WorkManager替代，适合周期性或延迟任务。

七、线程管理最佳实践

避免主线程阻塞：所有耗时操作（网络、IO、计算）必须放在子线程。
优先使用线程池：减少线程创建销毁开销，控制并发数（避免CPU过载）。
线程安全处理 ：共享资源需用synchronized、Lock或原子类保证安全。
及时释放资源 ：线程池、HandlerThread在不需要时需关闭（如shutdown()、quit()），避免内存泄漏。
Kotlin项目首选协程 ：协程轻量、易用，结合lifecycleScope可自动绑定生命周期，避免内存泄漏。
监控线程状态 ：通过Android Studio的Profiler工具监控线程数量、CPU占用，排查线程泄漏或过度创建问题。

总结

Android线程模型的核心是"主线程负责UI，子线程处理耗时任务"，线程间通信依赖Handler-Looper机制。实际开发中，需根据场景选择合适的线程创建方式（线程池、协程等），并注意线程安全和资源管理，以确保应用流畅运行，避免ANR和内存泄漏。