在并发编程中，锁（Lock）是一种用于控制多个线程对共享资源访问的机制。正确使用锁可以确保数据的一致性和完整性，避免出现竞态条件（Race Condition）、死锁（Deadlock）等问题。Java 提供了多种类型的锁来满足不同场景下的需求，从内置的对象锁到更高级别的 java.util.concurrent.locks 包中的显式锁。
为什么需要锁？
当多个线程同时尝试修改同一份数据时，如果没有适当的同步措施，可能会导致以下问题：
- 数据不一致：不同的线程读取到了部分更新的数据。
- 丢失更新：一个线程的更改被另一个线程覆盖。
- 脏读/写：线程读取或写入了尚未完成的操作。
为了解决这些问题，我们需要一种机制来协调线程之间的访问顺序，保证每次只有一个线程能够操作共享资源。这就是锁的作用所在。
Java 中的锁类型
内置锁（Intrinsic Lock）
也称为监视器锁（Monitor Lock），是通过关键字 synchronized 实现的。每个对象都有一个与之关联的内置锁，当一个线程进入由 synchronized 修饰的方法或代码块时，它会自动获取该对象的锁；而当方法执行完毕或遇到 wait() 调用时，则会释放锁。
public synchronized void method() {
// 只有一个线程可以进入这里
}public void method() {
synchronized (this) {
// 同样只有一个线程可以进入这里
}
}显式锁（Explicit Lock）
从 Java 5 开始，java.util.concurrent.locks 包引入了更为灵活和强大的锁接口——Lock。相比于内置锁，显式锁提供了更多的功能，如可中断的锁等待、超时获取锁以及公平锁等特性。
ReentrantLock
ReentrantLock 是最常用的显式锁实现之一，它允许同一个线程多次获取同一把锁，并且必须按照获取的次数逐一释放。这使得递归调用成为可能。
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Counter {
private int count = 0;
private final Lock lock = new ReentrantLock();
public void increment() {
lock.lock();
try {
count++;
} finally {
lock.unlock(); // 确保无论如何都会解锁
}
}
public int getCount() {
return count;
}
}ReadWriteLock
ReadWriteLock 接口定义了一种读写分离的锁机制，其中读锁允许多个线程同时持有，但不允许写锁存在；反之，一旦有线程持有了写锁，其他所有试图获取读锁或写锁的线程都将被阻塞。这种设计非常适合读多写少的情况。
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class Cache {
private final Map<String, Object> map = new HashMap<>();
private final ReadWriteLock rwl = new ReentrantReadWriteLock();
public Object get(String key) {
rwl.readLock().lock();
try {
return map.get(key);
} finally {
rwl.readLock().unlock();
}
}
public void put(String key, Object value) {
rwl.writeLock().lock();
try {
map.put(key, value);
} finally {
rwl.writeLock().unlock();
}
}
}StampedLock
StampedLock 是 Java 8 新增的一种乐观锁，它结合了读写锁的功能并提供了更好的性能优化。它支持三种模式：读、写和乐观读。乐观读模式假设不会有冲突发生，因此不会阻塞其他线程；但如果检测到冲突，则需要回滚操作并重新尝试。
import java.util.concurrent.locks.StampedLock;
public class Point {
private double x, y;
private final StampedLock sl = new StampedLock();
void move(double deltaX, double deltaY) {
long stamp = sl.writeLock();
try {
x += deltaX;
y += deltaY;
} finally {
sl.unlockWrite(stamp);
}
}
double distanceFromOrigin() {
long stamp = sl.tryOptimisticRead();
double currentX = x, currentY = y;
if (!sl.validate(stamp)) {
stamp = sl.readLock();
try {
currentX = x;
currentY = y;
} finally {
sl.unlockRead(stamp);
}
}
return Math.sqrt(currentX * currentX + currentY * currentY);
}
}锁的使用原则
- 最小化锁定范围：尽量减少加锁的时间和区域，只保护真正需要保护的资源。
- 避免死锁：设计时要特别小心，防止形成循环等待链，即多个线程互相持有对方所需的锁。
- 使用超时机制：对于可能长时间阻塞的操作，考虑设置合理的超时时间以提高系统的健壮性。
- 优先选择高级并发工具：相比于原始的内置锁，应该更多地利用
java.util.concurrent包中提供的高级工具，因为它们通常更加安全可靠且易于使用。 - 文档化锁协议：清晰地记录各个锁之间的关系和使用规则，有助于后续维护人员理解代码逻辑。
最佳实践案例
使用 ReentrantLock 替代内置锁
在某些情况下，ReentrantLock 可以为我们提供比内置锁更多的灵活性。例如，它可以让我们实现非阻塞的锁尝试 (tryLock) 或者带超时的锁等待 (tryLock(long timeout, TimeUnit unit)).
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.TimeUnit;
public class BankAccount {
private double balance;
private final Lock lock = new ReentrantLock();
public boolean withdraw(double amount) throws InterruptedException {
if (lock.tryLock(1, TimeUnit.SECONDS)) {
try {
if (balance >= amount) {
balance -= amount;
return true;
}
} finally {
lock.unlock();
}
}
return false; // 超时未获得锁或余额不足
}
}使用 ReadWriteLock 优化读多写少场景
当应用程序中有大量读操作而写操作相对较少时，ReadWriteLock 可以显著提升性能，因为它允许多个线程同时进行读取，而不必像内置锁那样每次都排他地占用资源。
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class ConcurrentCache<K, V> {
private final Map<K, V> cache = new ConcurrentHashMap<>();
private final ReadWriteLock rwl = new ReentrantReadWriteLock();
public V get(K key) {
rwl.readLock().lock();
try {
return cache.get(key);
} finally {
rwl.readLock().unlock();
}
}
public void put(K key, V value) {
rwl.writeLock().lock();
try {
cache.put(key, value);
} finally {
rwl.writeLock().unlock();
}
}
}使用 StampedLock 进行乐观读
对于那些读操作远多于写操作，并且读操作之间几乎没有竞争的应用程序来说，StampedLock 的乐观读模式可以提供更高的吞吐量。它首先尝试无锁读取，只有在检测到潜在冲突时才会退回到传统的读锁方式。
import java.util.concurrent.locks.StampedLock;
public class OptimisticCounter {
private long count = 0;
private final StampedLock sl = new StampedLock();
public long readCount() {
long stamp = sl.tryOptimisticRead();
long localCount = count;
if (!sl.validate(stamp)) {
stamp = sl.readLock();
try {
localCount = count;
} finally {
sl.unlockRead(stamp);
}
}
return localCount;
}
public void increment() {
long stamp = sl.writeLock();
try {
count++;
} finally {
sl.unlockWrite(stamp);
}
}
}结语
感谢您的阅读！如果您对多线程锁或其他并发编程话题有任何疑问或见解，欢迎继续探讨。
