引言 🔒
在 Android 应用的开发过程中，随着业务需求的复杂度不断提升，多线程并发场景层出不穷。为了保证数据一致性与线程安全，锁（Lock）成为了不可或缺的工具。本篇博客将深入剖析 Android 中常用的锁机制、使用场景与最佳实践，并配以精炼的示例代码与示意图，帮助你快速掌握锁的精髓。
一、锁的基本概念
1. 什么是锁？
锁是一种同步机制，用于控制多个线程对共享资源的访问，确保在同一时刻只有一个线程能够进入临界区（Critical Section），从而避免数据竞争与不一致。
2. 锁的作用
- 互斥访问：保证同一资源在同一时刻仅被一个线程修改。
- 可见性保证：在释放锁后，修改对其他线程可见。
- 阻塞与等待：线程无法获取锁时，会被挂起或进入等待队列，直至锁可用。
3. 为什么在 Android 开发中需要锁？
- UI 线程与后台线程交互需保证同步；
- 缓存、数据库、网络调用等资源共享需防止数据竞争；
- 多进程组件（ContentProvider、AIDL）之间的同步需求。
二、线程与并发基础知识回顾 🧵
在深入锁之前，先回顾 Android 常用的线程与并发工具：
- Thread：直接创建线程，使用
new Thread(runnable).start()。 - Handler & Looper：用于在特定线程（通常是主线程）中传递消息与任务。
- HandlerThread：封装了 Looper 的后台线程。
- ExecutorService（线程池）：包括
ThreadPoolExecutor、ScheduledThreadPoolExecutor等，可复用线程，控制并发度。
// 简单线程池示例
ExecutorService pool = Executors.newFixedThreadPool(4);
pool.submit(() -> {
// 后台任务
});
pool.shutdown();
🔍 图示：线程模型示意图（伪代码注释提示）
[UI线程] <--Handler--> [HandlerThread] ---> ThreadPool
三、Java 中的锁机制 🧩
3.1 synchronized
- 定义：Java 语言关键字，隐式获取对象或类的监视器锁。
- 语法：方法锁、代码块锁。
// 方法锁
public synchronized void doWork() { ... }
// 块锁
synchronized (lockObject) {
// 临界区
}
✅ 优点：语法简洁，隐式释放锁；
⚠️ 缺点：不可中断、不支持公平锁、功能有限。
3.2 ReentrantLock
- 定义：Java
java.util.concurrent.locks包中的可重入锁。 - 特性：支持公平锁、可中断锁、尝试加锁（
tryLock()）。
ReentrantLock lock = new ReentrantLock(true); // fair = true
try {
lock.lockInterruptibly();
// 临界区
} finally {
lock.unlock();
}
🔄 可重入性：同一线程可多次获取锁；
⏰ 可中断：获取锁时可响应中断。
3.3 ReadWriteLock
- 定义：读写分离锁，允许多个读线程并发，写线程独占。
ReadWriteLock rwLock = new ReentrantReadWriteLock();
Lock readLock = rwLock.readLock();
Lock writeLock = rwLock.writeLock();
readLock.lock();
try { ... } finally { readLock.unlock(); }
writeLock.lock();
try { ... } finally { writeLock.unlock(); }
📖 场景：读多写少的数据访问，如缓存读取。
3.4 Semaphore
- 定义：计数信号量，控制同时访问某资源的线程数。
Semaphore sem = new Semaphore(3);
sem.acquire();
try { ... } finally { sem.release(); }
🎛️ 场景：限制并发连接数、线程池实现原理。
3.5 CountDownLatch
- 定义：线程间等待工具，等待其他线程执行完毕后继续。
CountDownLatch latch = new CountDownLatch(5);
for (int i = 0; i < 5; i++) {
new Thread(() -> {
// 任务
latch.countDown();
}).start();
}
latch.await(); // 等待所有子线程完成
🔐 场景：并行准备+主线程等待。
3.6 CyclicBarrier
- 定义：可循环使用的屏障，等待一组线程到达同一点后再继续。
CyclicBarrier barrier = new CyclicBarrier(3, () -> {
// 全部线程到达后执行
});
for (int i = 0; i < 3; i++) {
new Thread(() -> {
// 工作
barrier.await();
}).start();
}
🚧 场景：多线程分阶段计算。
四、锁在 Android 开发中的典型应用场景 🧠
4.1 多线程更新 UI 的同步
- 问题：Android UI 只能在主线程更新，后台线程需切换。
- 方案：使用
runOnUiThread()、Handler、synchronized等保证顺序。
synchronized (uiLock) {
runOnUiThread(() -> {
// 更新 UI
});
}
💡 示例图：UI线程与后台线程交互时序图。
4.2 数据缓存的并发访问控制
- 场景：内存缓存如 LruCache，多线程同时读取和写入。
- 方案：
ReadWriteLock分离读写；或ConcurrentHashMap。
private final ReadWriteLock cacheLock = new ReentrantReadWriteLock();
public Bitmap get(String key) {
cacheLock.readLock().lock();
try { return cache.get(key);}
finally { cacheLock.readLock().unlock(); }
}
4.3 多进程同步
- 场景：使用
ContentProvider或 AIDL 实现进程间通信（IPC），需要同步访问共享资源。 - 方案：在
ContentProvider中使用数据库事务锁；在 AIDL 服务端使用synchronized或ReentrantLock。
📦 图示：AIDL 服务多进程调用时序图。
4.4 网络请求和数据库操作的线程安全处理
- 网络请求：使用 OkHttp 自带连接池，限制并发；
- 数据库：Room 默认支持多线程读写，事务内操作自动加锁；
- 手动加锁：对执行顺序敏感时，可使用
Semaphore控制并发量。
Semaphore netSem = new Semaphore(10);
netSem.acquire();
try {
Response resp = okHttpClient.newCall(request).execute();
} finally {
netSem.release();
}
五、synchronized vs ReentrantLock 对比 📦
| 特性 | synchronized | ReentrantLock |
|---|---|---|
| 公平性 | 不可选公平 | 可选公平（fair 参数） |
| 可中断 | 不可中断 | 支持 lockInterruptibly() |
| 尝试加锁 | 不支持 | 支持 tryLock() |
| 条件变量 | wait/notify | Condition 对象 |
| 性能 | JDK 自动优化 | 需要手动释放锁 |
六、死锁与避免技巧 🔁
6.1 死锁的形成条件
- 互斥条件；
- 占有且等待；
- 不可剥夺；
- 循环等待；
6.2 常见案例
synchronized(a) {
synchronized(b) { ... }
}
synchronized(b) {
synchronized(a) { ... }
}
6.3 预防方法
- 锁顺序：统一的资源加锁顺序；
- 定时锁尝试：
tryLock(timeout)； - 资源分离：减少互斥区域；
- 死锁检测：借助工具（MAT、ThreadMXBean）。
七、最佳实践建议 💡
- 尽量避免锁：优先使用无锁数据结构（
ConcurrentHashMap、AtomicXXX）； - 控制粒度：最小化同步块；
- 读写分离：多读少写场景优先
ReadWriteLock； - 使用线程池：减少线程创建销毁成本；
- 文档与注释：明确锁的作用与风险；
- 监控与调优：借助工具监测锁竞争；
八、实用示例代码 🧪
8.1 高性能缓存示例
public class SafeCache<K, V> {
private final Map<K, V> cache = new HashMap<>();
private final ReadWriteLock lock = new ReentrantReadWriteLock();
public V get(K key) {
lock.readLock().lock();
try { return cache.get(key);}
finally { lock.readLock().unlock(); }
}
public void put(K key, V value) {
lock.writeLock().lock();
try { cache.put(key, value);}
finally { lock.writeLock().unlock(); }
}
}
注释：读写分离，保证多线程并发读取高效。
8.2 定时死锁尝试示例
ReentrantLock lockA = new ReentrantLock();
ReentrantLock lockB = new ReentrantLock();
void safeOperation() {
try {
if (lockA.tryLock(500, TimeUnit.MILLISECONDS)) {
try {
if (lockB.tryLock(500, TimeUnit.MILLISECONDS)) {
try {
// 安全操作
} finally { lockB.unlock(); }
}
} finally { lockA.unlock(); }
}
} catch (InterruptedException ignored) {}
}
九、高级内容拓展 🚀
9.1 Kotlin 协程与锁机制对比
- 协程调度：轻量级线程，挂起而非阻塞；
- Mutex：协程专用锁，支持
lock和withLock；
val mutex = Mutex()
suspend fun safeWrite() {
mutex.withLock {
// 协程内安全写操作
}
}
📊 对比表：传统锁 vs 协程 Mutex
9.2 使用 Channel 替代锁
- 场景：消息传递代替共享内存；
val channel = Channel<Int>()
launch {
for (msg in channel) { println(msg) }
}
launch {
channel.send(42)
}
