在多线程编程中，同步是确保共享资源正确访问并维护数据完整性的关键。Java提供了synchronized关键字来实现线程同步，但其局限性在于缺乏细粒度的控制，例如无法中断等待锁的线程或设置锁获取的超时时间。为了解决这些问题，Java在java.util.concurrent.locks包中引入了Lock接口及其实现类，如ReentrantLock和ReentrantReadWriteLock。这些工具提供了更灵活的同步机制，使开发者能够更好地优化并发性能。本文将详细探讨Lock接口和ReentrantReadWriteLock的使用方法，并通过示例展示其在实际场景中的应用。
理解Lock接口
Lock接口是java.util.concurrent.locks包的核心，提供了比synchronized关键字更显式和灵活的同步方式。通过Lock，开发者可以手动获取和释放锁，并利用其多种锁获取方式来满足不同需求。以下是Lock接口的主要方法及其功能：
| 方法 | 描述 | 使用场景 |
|---|---|---|
void lock() | 获取锁；若锁不可用，线程将等待直到获取锁。 | 用于需要确保获取锁的场景，需配合finally块释放锁。 |
void lockInterruptibly() | 获取锁，除非线程被中断；若中断，抛出InterruptedException。 | 适合需要响应中断的场景，需处理异常。 |
boolean tryLock() | 仅当锁立即可用时获取，返回true；否则返回false。 | 用于非阻塞锁尝试，避免线程长时间等待。 |
boolean tryLock(long time, TimeUnit unit) | 在指定时间内尝试获取锁，返回true或false；若中断，抛出InterruptedException。 | 用于设置超时，避免无限等待。 |
void unlock() | 释放锁。 | 必须在finally块中调用，确保锁释放。 |
Condition newCondition() | 返回与此锁关联的Condition对象。 | 用于复杂同步，如生产者-消费者模式。 |
使用模式
使用Lock时，推荐的模式是将锁获取和释放放在try-finally块中，以确保锁在任何情况下（包括异常）都能被释放。以下是一个典型示例：
Lock lock = new ReentrantLock();
try {
lock.lock();
// 执行临界区代码
} finally {
lock.unlock();
}
与synchronized相比，Lock的优点包括：
- 非阻塞尝试：
tryLock()允许线程在锁不可用时立即返回，而不是无限等待。 - 超时机制：
tryLock(long, TimeUnit)支持在指定时间内尝试获取锁。 - 中断支持：
lockInterruptibly()允许线程在等待锁时响应中断。 - 条件对象：通过
newCondition()，可以实现更复杂的同步逻辑。
这些特性使Lock在需要高并发或复杂同步逻辑的场景中更具优势。例如，在避免死锁或处理高争用资源时，Lock提供了更大的灵活性。
ReentrantReadWriteLock
在某些场景下，共享资源的读操作远多于写操作，使用单一锁（如ReentrantLock或synchronized）会导致不必要的性能瓶颈，因为它会序列化所有访问，包括并发的读操作。ReentrantReadWriteLock通过区分读锁和写锁解决了这一问题，允许多个线程同时持有读锁，而写锁则是独占的。
适用场景
ReentrantReadWriteLock特别适合以下场景：
- 读多写少：如缓存系统、数据库查询或Web投票应用，读操作频繁，写操作较少。
- 高并发读：允许多个线程同时读取数据，提高吞吐量。
- 数据一致性：写操作需要独占访问以确保数据完整性。
使用方法
ReentrantReadWriteLock实现了ReadWriteLock接口，提供了readLock()和writeLock()方法，分别返回读锁和写锁的Lock实例。以下是一个保护共享列表的示例：
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class ReadWriteList<E> {
private final List<E> list = new ArrayList<>();
private final ReadWriteLock lock = new ReentrantReadWriteLock();
private final Lock readLock = lock.readLock();
private final Lock writeLock = lock.writeLock();
public void add(E element) {
writeLock.lock();
try {
list.add(element);
} finally {
writeLock.unlock();
}
}
public E get(int index) {
readLock.lock();
try {
return list.get(index);
} finally {
readLock.unlock();
}
}
public int size() {
readLock.lock();
try {
return list.size();
} finally {
readLock.unlock();
}
}
}
在这个示例中：
get和size方法使用读锁，允许多个线程同时读取列表。add方法使用写锁，确保写操作独占访问，防止读写冲突。
投票应用示例
为了进一步说明ReentrantReadWriteLock的实际应用，考虑一个Web投票应用的场景，其中多个线程读取投票结果，而偶尔有线程更新投票数据。以下是一个简化示例：
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class ReadersWriterDemo {
private static final int NUM_READER_THREADS = 3;
private volatile boolean done = false;
private final BallotBox theData;
private final ReadWriteLock lock = new ReentrantReadWriteLock();
public ReadersWriterDemo() throws Exception {
List<String> choicesList = new ArrayList<>();
choicesList.add("同意");
choicesList.add("不同意");
choicesList.add("无意见");
theData = new BallotBox(choicesList);
}
public void demo() {
// 启动读线程
for (int i = 0; i < NUM_READER_THREADS; i++) {
Thread.startVirtualThread(() -> {
while (!done) {
lock.readLock().lock();
try {
theData.forEach(p ->
System.out.printf("%s: 票数 %d%n", p.getName(), p.getVotes()));
} finally {
lock.readLock().unlock();
}
try {
Thread.sleep((long)(Math.random() * 1000));
} catch (InterruptedException ex) {
// 忽略
}
}
});
}
// 启动写线程
Thread.startVirtualThread(() -> {
while (!done) {
lock.writeLock().lock();
try {
theData.voteFor((int)(Math.random() * theData.getCandidateCount()));
} finally {
lock.writeLock().unlock();
}
try {
Thread.sleep((long)(Math.random() * 1000));
} catch (InterruptedException ex) {
// 忽略
}
}
});
// 主线程等待后终止
try {
Thread.sleep(10 * 1000);
} catch (InterruptedException ex) {
// 忽略
} finally {
done = true;
}
}
public static void main(String[] args) throws Exception {
new ReadersWriterDemo().demo();
}
}
class BallotBox {
private final List<PollOption> options;
public BallotBox(List<String> choices) {
options = new ArrayList<>();
for (String choice : choices) {
options.add(new PollOption(choice));
}
}
public void voteFor(int index) {
if (index >= 0 && index < options.size()) {
options.get(index).incrementVotes();
}
}
public int getCandidateCount() {
return options.size();
}
public void forEach(java.util.function.Consumer<PollOption> action) {
options.forEach(action);
}
}
class PollOption {
private final String name;
private int votes;
public PollOption(String name) {
this.name = name;
this.votes = 0;
}
public String getName() {
return name;
}
public int getVotes() {
return votes;
}
public void incrementVotes() {
votes++;
}
}
在这个示例中，多个读线程定期读取投票结果，而一个写线程模拟用户投票。由于读操作远多于写操作，ReentrantReadWriteLock通过允许多个读线程同时访问数据显著提高了并发性能。
公平性与性能
ReentrantReadWriteLock支持公平性设置。默认情况下，它是非公平的，线程获取锁的顺序不保证，这可能导致某些线程长期等待（饥饿），但通常提供更高的吞吐量。如果需要公平性，可以通过构造函数指定：
ReadWriteLock lock = new ReentrantReadWriteLock(true); // 公平模式
公平模式下，锁将按照线程请求的顺序分配，但可能会降低性能。开发者需根据应用需求权衡公平性与性能。
锁降级
ReentrantReadWriteLock支持锁降级，即线程在持有写锁时可以获取读锁。这在某些场景下（如缓存更新）非常有用。例如：
lock.writeLock().lock();
try {
// 更新数据
lock.readLock().lock(); // 获取读锁
lock.writeLock().unlock(); // 释放写锁
// 使用读锁继续操作
} finally {
lock.readLock().unlock();
}
注意，锁升级（从读锁到写锁）是不支持的，因为这可能导致死锁。
最佳实践
使用锁时，遵循以下最佳实践可以避免常见问题：
- 在finally块中释放锁：确保锁在任何情况下（包括异常）都被释放，以防止死锁。
- 最小化锁持有时间：减少临界区代码的执行时间，以降低争用并提高并发性。
- 一致的锁顺序：在使用多个锁时，始终以固定顺序获取锁，以避免死锁。例如，总是先获取锁A再获取锁B。
- 理解公平性：非公平锁可能导致饥饿，但吞吐量更高。公平锁保证顺序，但性能较低。
- 避免嵌套锁：尽量减少锁的嵌套使用，因为这会增加死锁风险。
- 监控锁状态：
ReentrantReadWriteLock提供了查询方法（如getReadLockCount()、isWriteLocked()），可用于调试或监控。
高级主题：Condition对象
Lock接口支持Condition对象，通过newCondition()方法创建。Condition提供了类似Object的wait()和notify()的机制，但更灵活。例如，在生产者-消费者模式中，Condition可以用于等待特定条件：
Lock lock = new ReentrantLock();
Condition notFull = lock.newCondition();
Condition notEmpty = lock.newCondition();
lock.lock();
try {
while (/* 队列满 */) {
notFull.await();
}
// 添加元素
notEmpty.signal();
} finally {
lock.unlock();
}
由于Condition是一个高级主题，建议参考官方文档进一步学习：Java Condition Documentation。
结论
Lock接口及其实现（如ReentrantLock和ReentrantReadWriteLock）为Java中的多线程同步提供了比synchronized关键字更灵活和强大的工具。通过合理使用这些工具，开发者可以优化并发性能，尤其是在读多写少的场景中。无论是简单的互斥锁还是复杂的读写分离，java.util.concurrent.locks包都提供了可靠的解决方案。建议开发者深入研究官方文档，并结合实际场景实践这些技术。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
