正文

1、AQS是什么

AQS(AbstractQueuedSynchronizer)是一个用来构建锁和同步器的框架，使用AQS能简单且高效地构造出应用广泛的大量的同步器，比如我们提到的ReentrantLock，Semaphore，其他的诸如ReentrantReadWriteLock，SynchronousQueue，FutureTask等等皆是基于AQS的。

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

CLH(Craig,Landin,and Hagersten)队列是一个虚拟的双向队列(虚拟的双向队列即不存在队列实例，仅存在结点之间的关联关系)。AQS是将每条请求共享资源的线程封装成一个CLH锁队列的一个结点(Node)来实现锁的分配。

2、LockSupport的使用

LockSupport是JUC提供的一个线程阻塞与唤醒的工具类，该工具可以让线程在任意位置阻塞和唤醒。主要方法如下

public static void park(Object blocker);//无限期阻塞当前线程，带有blocker对象，用于确定线程阻塞的原因
public static void park();//无限期阻塞线程
public static void parkNanos(long nanos);//阻塞当前线程有阻塞时间限制
public static void parkNanos(Object blocker, long nanos);//阻塞当前线程有阻塞对象，有时间限制
public static void parkUntil(Object blocker, long deadline);//阻塞当前线程，直到某个时间
public static void unpark(Thread thread);//唤醒某个被阻塞的线程，只有线程阻塞了才会唤醒，不阻塞则不执行任何操作。

LockSuport简单使用

 public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            System.out.println("线程被阻塞了。。。。。。。1");
            LockSupport.park();
            System.out.println("线程被唤醒了。。。。。。。2");
        }, "t1");
        t1.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //准备唤醒线程
        System.out.println("准备唤醒线程了。。。。。。。。。3");
        LockSupport.unpark(t1);
    }

上面执行的结果为1,3,2，当线程被阻塞时只有调用unpark唤醒线程，线程才会继续执行。

LockSupport.park()与Thread.sleep()区别

Thread.sleep()没法从外部唤醒，只能等待自己醒来或者发生异常。而LockSupport.park()可以通过LockSupport.unpark()方法唤醒。

Thread.sleep()声明了InterruptedException中断异常，而LockSupport.park()方法不需要捕获异常

与Thread.sleep()相比，LockSupport.park()方法更精确、更灵活的阻塞和唤醒指定线程。

Thread.sleep()本身是一个native方法，LockSupport.park()是一个静态方法，但是底层调用了Unsafe类的native()方法。

Locksupport.park()允许设置一个Blocker对象，主要用来提供监视工具或者诊断工具确定线程受阻原因。

Thread.sleep()和Locksupport.park()都不会释放所持有的锁。

LockSupport.park()与Object.wait()区别

Object.wait()需要和synchronized关键字配合使用，而LockSuport.park()可以在任何地方执行。

Object.wait()同样需要抛出中断异常。LockSupport.park()不需要。

如果线程在没有wait()条件下执行notify()会抛出java.lang.IllegalMonitorStateException异常，而LockSupport.unpark()不会抛出任何异常。

Object.wait()会释放锁，而LockSupport.park()不会释放锁。

3、结合ReentrantLock分析AQS源码

本分析基于JDK17，与jdk8代码有一些不同，但思想是一样的。

ReentrantLock有以下几个内部类

abstract static class Sync extends AbstractQueuedSynchronizer{}//继承了AQS

static final class NonfairSync extends Sync {}//实现非公平锁的关键

static final class FairSync extends Sync {}//实现公平锁的关键

非公平加锁操作

NonfairSync类图结构如下

执行加锁操作会执行如下方法，一步一步解密加锁的过程。

initialTryLock()方法解读

1处的代码通过CAS操作将状态值state由0改为1如果修改成功，将当前线程设置为独占状态，然后返回true。因为lock()方法是（！initialTryLock()）所以就直接表示获取锁成功。

2处的代码表示将当前线程设置为独占状态。

3处的代码判断当前的线程是不是已经持有了锁，如果是同一个就表示重入锁，然后将转状态值state加1，并返回true表示获取锁成功。

acquire(1)方法解读

tryAcquire(1)方法解读

这个方法说明如果没有获取到锁，并不会直接将线程阻塞，而是通过CAS再次尝试一下是否可以获取到锁，如果获取到锁就直接返回，表示获取锁成功。不然则需要将线程加入队列等待。这里需要注意用到了模板方法的设计模式。

acquire()方法解读

final int acquire(Node node, int arg, boolean shared,
                      boolean interruptible, boolean timed, long time) {
        Thread current = Thread.currentThread();
        byte spins = 0, postSpins = 0;   // retries upon unpark of first thread
        boolean interrupted = false, first = false;
        Node pred = null;                // predecessor of node when enqueued
        /*
         * Repeatedly:
         *  Check if node now first
         *    if so, ensure head stable, else ensure valid predecessor
         *  if node is first or not yet enqueued, try acquiring
         *  else if node not yet created, create it
         *  else if not yet enqueued, try once to enqueue
         *  else if woken from park, retry (up to postSpins times)
         *  else if WAITING status not set, set and retry
         *  else park and clear WAITING status, and check cancellation
         */
        for (;;) {
            if (!first && (pred = (node == null) ? null : node.prev) != null &&
                !(first = (head == pred))) {
                if (pred.status < 0) {
                    cleanQueue();           // predecessor cancelled
                    continue;
                } else if (pred.prev == null) {
                    Thread.onSpinWait();    // ensure serialization
                    continue;
                }
            }
            if (first || pred == null) {
                boolean acquired;
                try {
                    if (shared)
                        acquired = (tryAcquireShared(arg) >= 0);
                    else
                        acquired = tryAcquire(arg);
                } catch (Throwable ex) {
                    cancelAcquire(node, interrupted, false);
                    throw ex;
                }
                if (acquired) {
                    if (first) {
                        node.prev = null;
                        head = node;
                        pred.next = null;
                        node.waiter = null;
                        if (shared)
                            signalNextIfShared(node);
                        if (interrupted)
                            current.interrupt();
                    }
                    return 1;
                }
            }
            if (node == null) {                 // allocate; retry before enqueue
                if (shared)
                    node = new SharedNode();
                else
                    node = new ExclusiveNode();
            } else if (pred == null) {          // try to enqueue
                node.waiter = current;
                Node t = tail;
                node.setPrevRelaxed(t);         // avoid unnecessary fence
                if (t == null)
                    tryInitializeHead();
                else if (!casTail(t, node))
                    node.setPrevRelaxed(null);  // back out
                else
                    t.next = node;
            } else if (first && spins != 0) {
                --spins;                        // reduce unfairness on rewaits
                Thread.onSpinWait();
            } else if (node.status == 0) {
                node.status = WAITING;          // enable signal and recheck
            } else {
                long nanos;
                spins = postSpins = (byte)((postSpins << 1) | 1);
                if (!timed)
                    LockSupport.park(this);
                else if ((nanos = time - System.nanoTime()) > 0L)
                    LockSupport.parkNanos(this, nanos);
                else
                    break;
                node.clearStatus();
                if ((interrupted |= Thread.interrupted()) && interruptible)
                    break;
            }
        }
        return cancelAcquire(node, interrupted, interruptible);
    }