JUC：ReentrantLock互斥锁

JUC：ReentrantLock

关键词

• 公平锁和非公平锁：ReentrantLock（CAS+AQS队列）
  公平锁和非公平锁的变量 private final Sync sync;（核心）
  tryAcquire()中实现，tryAcquire都会检查CLH队列中是否仍有前驱的元素，如果仍然有那么继续等待，通过这种方式来保证先来先服务的原则
• 可重入锁：ReentrantLock（state变量+CAS操作）
• 响应中断（一个线程获取不到锁，不会一直等下去）（tryLock方法，传入时间参数，表示等待指定的时间）
• 建议在高并发量情况下使用ReentrantLock（依赖于特殊的CPU指令）

---

一、概述

Concurrent 包中和互斥锁（ReentrantLock）相关类之间的继承层次

Lock是一个接口，其定义如下：

public interface Lock {
   
   
  void lock();  //不能被中断
  void lockInterruptibly() throws InterruptedException;  //可以被中断
  boolean tryLock();
  boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
  void unlock();
  Condition newCondition();
}

常用的方法是lock()/unlock()。lock()不能被中断，对应的lockInterruptibly()可以被中断。

1.2 ReentrantLock（可重入锁）本身没有代码逻辑，实现都在其内部类Sync中：

public class ReentrantLock implements Lock, java.io.Serializable {
   
   
  private final Sync sync;
 
  public void lock() {
   
   
    sync.acquire(1);
 }
 
  public void unlock() {
   
   
    sync.release(1);
 }
  // ...
}

1.3 锁的公平性vs.非公平性

Sync是一个抽象类，它有两个子类FairSync与NonfairSync，分别对应公平锁和非公平锁。从下面的ReentrantLock构造方法可以看出，会传入一个布尔类型的变量fair指定锁是公平的还是非公平的，默认为非公平的。

public ReentrantLock() {
   
   
	sync = new NonfairSync();
}

public ReentrantLock(boolean fair) {
   
   
	sync = fair ? new FairSync() : new NonfairSync();
}

什么叫公平锁和非公平锁呢？先举个现实生活中的例子，一个人去火车站售票窗口买票，发现现场有人排队，于是他排在队伍末尾，遵循先到者优先服务的规则，这叫公平；如果他去了不排队，直接冲到窗口买票，这叫作不公平。

对应到锁的例子，一个新的线程来了之后，看到有很多线程在排队，自己排到队伍末尾，这叫公平；线程来了之后直接去抢锁，这叫作不公平。默认设置的是非公平锁，其实是为了提高效率，减少线程切换。

调用lock()进行上锁，直接acquire(1)上锁

public void lock() {
   
   
	// 调用的sync的子类FairSync的lock()法：ReentrantLock.FairSync.lock()
	sync.lock();
}
	final void lock() {
   
   
		// 调用AQS的acquire()方法获取锁，传的值为1
		acquire(1);
	}

直接尝试获取锁

// AbstractQueuedSynchronizer.acquire
publicfinalvoidacquire(intarg) {
   
   
	// 尝试获取锁
  // 如果失败了，就排队 
  if (!tryAcquire(arg) &&
  		// 注意addWaiter()这里传入的节点模式为独占模式
			acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
			
		selfInterrupt();
	}	

1.4 锁实现的基本原理

Sync的父类AbstractQueuedSynchronizer经常被称作队列同步器（AQS），这个类非常重要，该类的父类是AbstractOwnableSynchronizer。

此处的锁具备synchronized功能，即可以阻塞一个线程。为了实现一把具有阻塞或唤醒功能的锁，需要几个核心要素：

1. 需要一个state变量，标记该锁的状态。state变量至少有两个值：0、1。对state变量的操作，使用CAS保证线程安全。
2. 需要记录当前是哪个线程持有锁。（Thread exclusiveOwnerThread; // 记录持有锁的线程）
3. 需要底层支持对一个线程进行阻塞或唤醒操作。
4. 需要有一个队列维护所有阻塞的线程。这个队列也必须是线程安全的无锁队列，也需要使用CAS。

针对要素1和2，在上面两个类中有对应的体现：

public abstract class AbstractOwnableSynchronizer implements java.io.Serializable {
   
   
  // ...
  private transient Thread exclusiveOwnerThread;  // 记录持有锁的线程
}

public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer implements java.io.Serializable {
   
   
 
  private volatile int state; // 记录锁的状态，通过CAS修改state的值。
  // ...
 
}

state取值不仅可以是0、1，还可以大于1，就是为了支持锁的可重入性。例如，同样一个线程，调用5次lock，state会变成5；然后调用5次unlock，state减为0。

• 当state=0时，没有线程持有锁，exclusiveOwnerThread=null；

• 当state=1时，有一个线程持有锁，exclusiveOwnerThread=该线程；

• 当state > 1时，说明该线程重入了该锁

对于要素3，Unsafe类提供了阻塞或唤醒线程的一对操作原语，也就是park/unpark。

public native void unpark(Object thread);