详解Java AQS原理

详解Java AQS原理

AQS全程全称AbstractQueuedSynchronizer，是JDK提供的一个同步框架，抽象队列同步器，内部维护FIFO双向队列，即CLH同步队列，AQS依赖这个同步队列来管理同步状态（voliate修饰的state，用于标志是否持有锁）。

当线程获取state失败时，会将当前线程和等待信息等构建成一个Node，将Node放在队列中，同步阻塞当前线程，当state释放时，会把队列中首节唤醒，使其获得同步状态state

底层阻塞线程使用的时park和unpark

AQS把state的修改交给子类来实现，但是子类并不需要关系CLH队列的问题

1.继承关系

public abstract class AbstractQueuedSynchronizer
    extends AbstractOwnableSynchronizer
    implements java.io.Serializable {

该类是一个抽象类,继承AbstractOwnableSynchronizer抽象类，该类的成员是一个Thread ，用来表示当前的Owner线程，并提供了设置和获取Owner线程的方法，并用final修饰，这样做是并不希望子类去重写Owner线程的设置方法。（Owner线程就是当前运行中的线程，其他线程获得锁后就会设置为Owner线程）

2.线程状态state

private volatile int state;

若一个线程想获得锁，就是CAS来修改state的值，0表示无锁，1表示已经加锁了

3.Node静态内部类

在这里可以知道AQS支持独享锁和共享锁两种模式

static final class Node {
    	// 用SHARED和EXCLUSIVE来区分独享锁和共享锁两种模式
        static final Node SHARED = new Node();
        static final Node EXCLUSIVE = null;
   		// 一些状态
        static final int CANCELLED =  1;
        static final int SIGNAL    = -1;
        static final int CONDITION = -2;
        static final int PROPAGATE = -3;
    	// 结点的等待状态  修改改状态也需要CAS
        volatile int waitStatus;
  		// 前置结点
        volatile Node prev;
    	// 后置结点
        volatile Node next;
    	// 结点包含的线程信息
        volatile Thread thread;
        Node nextWaiter;
        final boolean isShared() {
            return nextWaiter == SHARED;
        }
        final Node predecessor() throws NullPointerException {
            Node p = prev;
            if (p == null)
                throw new NullPointerException();
            else
                return p;
        }
        Node() {    // Used to establish initial head or SHARED marker
        }
        Node(Thread thread, Node mode) {     // Used by addWaiter
            this.nextWaiter = mode;
            this.thread = thread;
        }
        Node(Thread thread, int waitStatus) { // Used by Condition
            this.waitStatus = waitStatus;
            this.thread = thread;
        }
    }

当CAS修改state失败时，会创建一个包含线程信息的Node放入队列中

4.独享锁获取锁的方法

4.1Acquire(int arg)

 public final void acquire(int arg) {
     // 想要获取锁，首先要通过tryAcquire来尝试获取，如果获取失败，就acquireQueued(addWaiter(Node.EXCLUSIVE), arg)
     if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
     {
         // 尝试获得锁失败，并且添加结点到队列中成功，就会进行该方法
         selfInterrupt();
     }
 }

4.2tryAcquire(int arg)

//这个方法在AQS中直接会抛出一个**UnsupportedOperationException**异常，这里利用了模板模式，子类需要重写这个方法，如果不重写，就会抛出错误。
//子类实现一般就是ACS来修改state

4.3addWaiter(Node mode)

添加一个等待的线程，此方法成功后会将该线程封装成Node添加到队列的尾部，并返回该Node，用于park

private Node addWaiter(Node mode) {
    // 创建一个结点，包含了线程信息
    Node node = new Node(Thread.currentThread(), mode);
    // Try the fast path of enq; backup to full enq on failure
    Node pred = tail;
    if (pred != null) {
        node.prev = pred;
        // CAS设置新结点为Tail尾结点
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    // 如果pred不是null，说明执行到这里的时候，前置结点已经被删除了，就执行enq()
    enq(node);
    // 成功将该结点放入队列队尾
    return node;
}

// 循环设置结点到队尾，直到成功   
private Node enq(final Node node) {
    for (;;) {
        Node t = tail;
        // 如果队列为空，先创建一个空的Node当作头节点
        if (t == null) { // Must initialize
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

4.4acquireQueued(final Node node, int arg)

循环执行，线程对应的结点不是头结点的下一个结点，则会进入等待状态，如果prev是头结点，才有资格去争夺锁

final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        // 在循环中
        for (;;) {
            final Node p = node.predecessor();
            // 如果这个结点的前置结点是头结点，就尝试获取一下锁，如果成功，返回阻塞失败的通知
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            // 该方法来确定是否可以安心的去阻塞，就是看前驱结点是否状态为SIGNAL
            if (shouldParkAfterFailedAcquire(p, node) &&
                // LockSupport.park(this);  -> 这里就是调用park方法来阻塞线程
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

4.5shouldParkAfterFailedAcquire(p, node)

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL)
		// 如果前置结点状态是SIGNAL，就表示它可以它有义务叫醒当前结点，它就可以安心去被阻塞了
        return true;
    if (ws > 0) {
        // 如果前置结点> 0, 说明已经被取消，就删除它并向前一直找到可以有义务叫醒它的结点
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        // 其他情况通过CAS设置前驱结点的状态为SIGNAL
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

4.6selfInterrupt()

static void selfInterrupt() {
		// 直接打断当前线程
        Thread.currentThread().interrupt();
}

5独享锁释放锁的方法

5.1release(int arg)

public final boolean release(int arg) {
    // tryRelease 类似 tryAcquire 需要子类重写，否则抛出错误
    if (tryRelease(arg)) {
        Node h = head;
        // 先找到队列的头节点，如果它状态不是0，就进入unpark它的下一个结点代表的线程
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

5.2unparkSuccessor(Node node)

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;
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    if (s != null)
        // 释放该结点表示的线程
        LockSupport.unpark(s.thread);
}
```、