AQS深入剖析实现原理

AQS(AbstractQueueSynchronizer)

概念

• AQS是什么？

从全称可以看出，它是一个抽象类，并且内部由一个双向链表结构提供的FIFO队列(CLH)存放因没有获取到资源的线程

• AQS作用？

在多线程环境下，为了保证共享资源安全的使用，以及线程之间的同步，java提供了一个AQS供其子类扩展。

例如ReentrantLock就是一种排他锁，保证仅有一个线程获取锁资源进入同步块执行代码，其他未获取锁线程阻塞起来等待被唤醒。

CountDownLath/Semaphore/CyclicBarrier/ReentrantReadWriteLock 是一种共享锁，允许多个线程一起共享资源

AbstractQueueSynchronizer类内部组成

private transient volatile Node head;//队列头
   
private transient volatile Node tail;//队列尾
   
private volatile int state;//同步状态，互斥锁state只有0和1 共享锁state表示可共享资源个数
//队列中节点类   
static final class Node {
   //当前线程中的状态 -1表示后继节点中的线程需要被unpark也就是从阻塞中唤醒
   //1 CANCELLED 表示取消 线程中断或等待超时
   //-2 CONDITION 表示当前线程正在等待其他线程调用signal唤醒
   //-3 PROPAGATE 共享模式下释放资源时，依次唤醒多个阻塞的线程
	volatile int waitStatus;
   volatile Node prev;
   volatile Node next;
   //阻塞的线程
   volatile Thread thread;
   //当线程获取排他锁时调用codition.await()就会将线程进入等待队列中，当其他线程获取到排他锁调用signal时才会将等待队列中的线程转移到同步锁队列中，让此线程重新竞争锁资源
   Node nextWaiter;
}

//以下为抽象方法，提供给子类实现，利用是抽象模板模式，AQS会调用tryAccquire*方法，由子类提供具体逻辑，AQS会根据tryAccquire返回结果判断是否需要将该线程放入队列中阻塞起来
//排他模式
protect boolean tryAcquire(int arg);
protect boolean tryRelease (int arg);

//共享模式
protected int tryAcquireShared(int arg)
protected boolean tryReleaseShared(int arg)

AQS通过一个循环使用CAS保证一个节点能在多线程环境下进入同步队列中，为了避免线程未获取到资源时直接阻塞起来，而是多次调用tryAcquire方法，当方法返回true时则表示获取到资源，否则会阻塞线程

总结：

AQS提供了存放未获取资源的线程和当资源可用时唤醒线程逻辑，具体是否需要阻塞和是否需要唤醒其他线程实现在子类中实现的。

AQS涉及到CAS+同步队列、条件队列

ReentrantLock

类结构

ReentrantLock类中使用到FairSync和NonFairSync，表示公平锁和非公平锁，其都是继承于Sync类，而Sync就是继承于AbstractQueueSync,下面会解释锁公平锁和非公平锁为什么不同。

非公平加锁流程

加锁的时序图

  static final class NonfairSync extends Sync {
    private static final long serialVersionUID = 7316153563782823691L;

    final void lock() {
    //通过CAS竞争锁，如果获取锁成功则将排他锁拥有者设置为当前线程
        if (compareAndSetState(0, 1))
            setExclusiveOwnerThread(Thread.currentThread());
        else
            acquire(1);//调用AQS中的acquire方法
    }

    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }
}

AQS中的acquire方法

 1、调用子类重写的tryAcquire方法，返回true表示获取锁成功进入同步块，返回false进入2
 2、调用addWaiter方法创建一个节点，通过CAS将该节点插入到队尾
 3、acquireQueued 将未获取到资源的线程阻塞
 
 
  public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

NonFairSync中的tryAcquire方法

      protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }

NonFairSync的父类中的nonfairTryAcquire方法

   final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
            //CAS竞争锁
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            //如果同步获取锁的线程和当前占用锁的线程相同时无需额外同步直接获取，就是锁重入，所以lock和unlock必须要成对出现
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

AQS.addWaiter 将节点放入队列中

private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);
        // 尝试快速在队尾加入该节点，但是有可能其他线程已经捷足先登了，将tail指针指向新的节点，那么就会导致CAS失败，则进入enq方法
        Node pred = tail;
        if (pred != null) {
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        enq(node);
        return node;
    }

AQS.enq 使用一个循环通过CAS操作直到将节点追加到队尾

private Node enq(final Node node) {
        for (;;) {
            Node t = tail;
            if (t == null) { // 链表头节点并不是一开始就创建的，而是当有节点入队时才会生成 
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }

AQS.acquireQueued 方法

final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor();
                //如果当前节点前驱节点是头节点，并且尝试获取锁成功则将该节点升级为head节点表示head节点为当前运行的线程
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

AQS.shouldParkAfterFailedAcquire 方法

//保证将要阻塞的线程前驱节点的waitStatus=-1才会将当前线程阻塞起来,并将已经取消的节点移除
 private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;
        if (ws == Node.SIGNAL)
          
            return true;
        if (ws > 0) {
            
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
          、
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }

AQS.parkAndCheckInterrupt

 //将线程park，直到获取资源线程调用unlock操作，将阻塞的线程唤醒重新获取锁资源
  private final boolean parkAndCheckInterrupt() {
        LockSupport.park(this);
        return Thread.interrupted();
    }

非公平释放锁

在ReentrantLock中的unlock方法使用了帮助类Sync的relase方法(实际上是AQS中release方法，因为Sync继承了AQS类)

 public void unlock() {
        sync.release(1);
    }

AQS.release()

public final boolean release(int arg) {
//实际上调用子类中实现的tryRelease方法，若返回true表示需要唤醒同步队列中阻塞的线程
        if (tryRelease(arg)) {
            Node h = head;
            //只有当head节点不是null并且等待状态不是初始值时
            if (h != null && h.waitStatus != 0)
            //唤醒阻塞的线程
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

Sync.tryRelease

 //如果当前线程和占用锁的线程不同的话会抛出IllegalMonitorStateException异常，可以看到此方法并没有使用CAS操作保证线程安全，因为在加锁的时候只保证了一个线程获取锁，当然释放锁的时候也是只有一个线程的
 protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            //当state值为0时表示当前线程已经释放完了锁
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }

AQS.unparkSuccessor

private void unparkSuccessor(Node node) {
       
        int ws = node.waitStatus;
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);

        Node s = node.next;
        if (s == null || s.waitStatus > 0) {
            s = null;
            //从队尾向前扫描找到最前面一个状态不是CANCELLED的节点，并取出该节点thread唤醒，然后改线程从阻塞的地方继续往下执行循环获取锁，若竞争锁失败还是会将该线程阻塞起来
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)
                    s = t;
        }
        if (s != null)
            LockSupport.unpark(s.thread);
    }

两个线程 T1 T2 T3竞争锁资源时，当T1成功获取锁资源了，则以下是同步队列中节点状态变化图

当T2线程未获取到资源时，首先会创建Node node，该节点中包含T2线程对象的引用，当前head指向null那么就会创建一个head节点，然后node节点插入到对尾

公平锁和非公平锁区别

优缺点

公平锁防止线程饿死，但是吞吐量和系统响应时间会降低，当有个线程获取锁时执行时间很长时导致占用锁时间很长，影响其他执行时间很多线程获取

非公平锁会导致其他线程长时间获取不到锁，吞吐量和响应时间都会大大提高

实现方式上

公平锁和非公平锁在tryAcquire方法上实现不同

公平锁的实现是当发现当前有同步队列时，就会让线程进入同步队列排队，等待被唤醒竞争锁

非公平锁的实现是不管有其他线程在等待获取锁，而是每次都会使用CAS竞争锁