ReentrantLock

最新推荐文章于 2023-12-19 23:40:17 发布

转载最新推荐文章于 2023-12-19 23:40:17 发布 · 265 阅读

并发编程专栏收录该内容

6 篇文章

订阅专栏

本文详细探讨了ReentrantLock中的公平锁与非公平锁的区别及其内部实现原理。介绍了AQS框架如何支持这两种锁机制，并解释了Condition接口如何帮助管理线程间的等待与通知。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

在ReentrantLock中很明显可以看到其中同步包括两种，分别是公平的FairSync和非公平的NonfairSync。公平锁的作用就是严格按照线程启动的顺序来执行的，不允许其他线程插队执行的；而非公平锁是允许插队的。

默认情况下ReentrantLock是通过非公平锁来进行同步的，包括synchronized关键字都是如此，因为这样性能会更好。当执行加锁操作时，公平性将由于挂起线程和恢复线程时存在的开销将极大的降低性能。在实际情况下，统计上的公平性，确保被阻塞的线程能最终获得锁，通常已经够用了。

当使用非公平锁的时候，会立刻尝试配置状态，成功了就会插队执行，失败了就会和公平锁的机制一样，调用acquire()方法，以排他的方式来获取锁，成功了立刻返回，否则将线程加入队列，知道成功调用为止

从上图我们可以看到，ReentrantLock实现Lock接口，Sync与ReentrantLock是组合关系，且FairSync（公平锁）、NonfairySync（非公平锁）是Sync的子类。Sync继承AQS（AbstractQueuedSynchronizer）。在具体分析lock时，我们需要了解几个概念：

AQS（AbstractQueuedSynchronizer）：为java中管理锁的抽象类。该类为实现依赖于先进先出 (FIFO) 等待队列的阻塞锁和相关同步器（信号量、事件，等等）提供一个框架。

CLH：AQS中“等待锁”的线程队列。我们知道在多线程环境中我们为了保护资源的安全性常使用锁将其保护起来，同一时刻只能有一个线程能够访问，其余线程则需要等待，CLH就是管理这些等待锁的队列。

CAS（compare and swap）：比较并交换函数，它是原子操作函数，也就是说所有通过CAS操作的数据都是以原子方式进行的。

Condition从字面上面理解就是条件。对于线程而言它为线程提供了一个含义，以便在某种状态（条件Condition）可能为true的另一个线程通知它之前，一直挂起该线程。

Condition 将 Object 监视器方法（wait、notify 和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意 Lock 实现组合使用，为每个对象提供多个等待 set（wait-set）。其中，Lock 替代了 synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法的使用。

条件（也称为条件队列或条件变量）为线程提供了一个含义，以便在某个状态条件现在可能为 true 的另一个线程通知它之前，一直挂起该线程（即让其“等待”）。因为访问此共享状态信息发生在不同的线程中，所以它必须受保护，因此要将某种形式的锁与该条件相关联。等待提供一个条件的主要属性是：以原子方式释放相关的锁，并挂起当前线程，就像 Object.wait 做的那样。

Condition 实例实质上被绑定到一个锁上。要为特定 Lock 实例获得 Condition 实例，请使用其newCondition() 方法。下面我们通过Condition来解决上面的问题：这里只改仓库Depot的代码

class Depot{
	private int size;
	private int capacity;
	private Lock lock;
	
	private Condition fullCondition;
	private Condition emptyCondition;
	
	public Depot() {
		size = 0;
		capacity = 15;
		lock = new ReentrantLock();
		fullCondition = lock.newCondition();
		emptyCondition = lock.newCondition();
	}
	
	public void put(int value) {
		lock.lock();
		try {
			
			int left = value;
			while (left > 0) {
				while (size > capacity) {
					fullCondition.await();
				}
				int inc = (size + left) > capacity ? capacity - size : left;
				size = size + inc;
				left -= inc;
				System.out.println(Thread.currentThread().getName() + "要入库数量  :" + value
						+ "实际入库数量   :" + inc);
				emptyCondition.signal();
			}
		} catch (Exception e) {
			// TODO: handle exception
		} finally {
			lock.unlock();
		}
	}
	
	public void get(int value){
		lock.lock();
		try {
			int left = value;
			while (left > 0){
				while (size <= 0){
					emptyCondition.wait();
				}
				int dec = size > left ? left : size;
				size -= dec;
				left -= dec;
				System.out.println(Thread.currentThread().getName() + "要消费数量  :" + value
						+ "实际消费数量   :" + dec);
			}
		} catch (Exception e) {
			// TODO: handle exception
		}finally {
			lock.unlock();
		}
	}
	
}