多线程锁

在并发编程中，锁（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);}}
}

结语

感谢您的阅读！如果您对多线程锁或其他并发编程话题有任何疑问或见解，欢迎继续探讨。