AQS与ReentrantLock

AQS 核心思想是，如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并且将共享资源设置为锁定状态。如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制，这个机制 AQS 是用 CLH 队列锁 实现的，即将暂时获取不到锁的线程加入到队列中。

CLH(Craig,Landin,and Hagersten) 队列是一个虚拟的双向队列（虚拟的双向队列即不存在队列实例，仅存在结点之间的关联关系）。AQS 是将每条请求共享资源的线程封装成一个 CLH 锁队列的一个结点（Node）来实现锁的分配。在 CLH 同步队列中，一个节点表示一个线程，它保存着线程的引用（thread）、 当前节点在队列中的状态（waitStatus）、前驱节点（prev）、后继节点（next）。

CLH 队列结构如下图所示：

*  +------+  prev +-------+       +------+
*  | head | <---- | first | <---- | tail |
*  +------+ ----> +-------+ ----> +------+
*           next

AQS(AbstractQueuedSynchronizer)的核心原理图（图源Java 并发之 AQS 详解）如下：

AQS介绍

//AQS 使用 int 成员变量 state 表示同步状态，通过内置的 线程等待队列 来完成获取资源线程的排队工作。
// state 变量由 volatile 修饰，用于展示当前临界资源的获锁情况。
private volatile int state;
// 获取当前state的值
protected final int getState() {
    return state;
}
// 初始化时给state赋值
protected final void setState(int newState) {
    state = newState;
}
// 原子地（CAS操作）将同步状态值设置为给定值update如果当前同步状态的值等于expect（期望值）
protected final boolean compareAndSetState(int expect, int update) {
    return U.compareAndSetInt(this, STATE, expect, update);
}

AQS定义两种资源共享方式：Exclusive（独占，只有一个线程能执行，如ReentrantLock）和Share（共享，多个线程可同时执行，如Semaphore/CountDownLatch）。

不同的自定义同步器争用共享资源的方式也不同。自定义同步器在实现时只需要实现共享资源state的获取与释放方式即可，至于具体线程等待队列的维护（如获取资源失败入队/唤醒出队等），AQS已经在顶层实现好了。自定义同步器实现时主要实现以下几种方法：

• isHeldExclusively()：该线程是否正在独占资源。只有用到condition才需要去实现它。
• tryAcquire(int)：独占方式。尝试获取资源，成功则返回true，失败则返回false。
• tryRelease(int)：独占方式。尝试释放资源，成功则返回true，失败则返回false。
• tryAcquireShared(int)：共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。
• tryReleaseShared(int)：共享方式。尝试释放资源，如果释放后允许唤醒后续等待结点返回true，否则返回false。

ReentrantLock 可重入锁

默认非公平锁，带参数的true是公平锁，false是非公平锁

/**
 * Creates an instance of {@code ReentrantLock}.
 * This is equivalent to using {@code ReentrantLock(false)}.
 */
public ReentrantLock() {
    sync = new NonfairSync();
}

/**
 * Creates an instance of {@codeReentrantLock} with the
 * given fairness policy.
 *
 *@paramfair {@codetrue} if this lock should use a fair ordering policy
 */
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

// tryLock 默认执行非公平锁的上锁方式
final boolean tryLock() {
    Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        if (compareAndSetState(0, 1)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    } else if (getExclusiveOwnerThread() == current) {
        if (++c < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(c);
        return true;
    }
    return false;
}

// lock加锁根据tryAcquire的实现进行不同的加锁方式
final void lock() {
    if (!initialTryLock())
        acquire(1);
}

public final void acquire(int arg) {
		// 如果获取锁成功，则什么都不执行，如果获取锁失败，执行acquire，把节点放入等待队列
		if (!tryAcquire(arg))
        acquire(null, arg, false, false, false, 0L);
}

公平锁

protected final boolean tryAcquire(int acquires) {
		// state=0，没有比当前线程等待时间长的线程，aqs设置state成功
    if (getState() == 0 && !hasQueuedPredecessors() &&
        compareAndSetState(0, acquires)) {
				// 设置独占锁当前占有者
        setExclusiveOwnerThread(Thread.currentThread());
        return true;
    }
    return false;
}

/**
 * 查询是否有线程等待获取的时间比当前线程长
 */
public final boolean hasQueuedPredecessors() {
        Thread first = null; Node h, s;
				//（h等于头结点，并且不等于null）&&（s等于h的下一个节点）||（first等于s的等待线程等于null）||（s的上一个节点等于null）
        if ((h = head) != null && ((s = h.next) == null ||
                                   (first = s.waiter) == null ||
                                   s.prev == null))
				// 返回队列中第一个(等待时间最长的)线程，如果当前没有线程排队，则返回null
            first = getFirstQueuedThread(); // retry via getFirstQueuedThread
        // 第一个节点有线程，并且不是自己返回true
				return first != null && first != Thread.currentThread();
    }

// 仅在可重入对象或队列为空时获取
final boolean initialTryLock() {
	  Thread current = Thread.currentThread();
	  int c = getState();
	  if (c == 0) {
	      if (!hasQueuedThreads() && compareAndSetState(0, 1)) {
	          setExclusiveOwnerThread(current);
	          return true;
	      }
	  } else if (getExclusiveOwnerThread() == current) {
	      if (++c < 0) // overflow
	          throw new Error("Maximum lock count exceeded");
	      setState(c);
	      return true;
	  }
	  return false;
}

非公平锁 不进行比较，直接对state进行修改，成功则抢占到锁

protected final boolean tryAcquire(int acquires) {
    if (getState() == 0 && compareAndSetState(0, acquires)) {
        setExclusiveOwnerThread(Thread.currentThread());
        return true;
    }
    return false;
}
// 非公平锁下是否可重入判断,仅在可重入对象或队列为空时获取
final boolean initialTryLock() {
    Thread current = Thread.currentThread();
    if (compareAndSetState(0, 1)) { // first attempt is unguarded
        setExclusiveOwnerThread(current);
        return true;
    } else if (getExclusiveOwnerThread() == current) {
        int c = getState() + 1;
        if (c < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(c);
        return true;
    } else
        return false;
}