并发编程学习笔记(5)—-AbstractQueuedSynchronizer（AQS）原理及使用

（一）什么是AQS?

阅读java文档可以知道，AbstractQueuedSynchronizer是实现依赖于先进先出 (FIFO) 等待队列的阻塞锁和相关同步器（信号量、事件，等等）提供一个框架，它是一个依靠单个原子 int 值来表示状态的大多数同步器的一个基础类。在jdk中他的实现的类有Semaphore，ReentrantLock，CountDownLatch，ReentrantReadWriteLock等等很多的实现。

（二）原理

　　它通过实现一个volatile int state来维护线程的状态，并使用一个双向链表来维护多个线程的等待队列。一般将子类作为一个非公共的内部帮助器类。它存在有独享和共享两种模式，在独享模式下，当锁被占用时，其他线程试图获取锁一定不会成功，共享模式下其他线程获取锁可能会成功。（读写锁读-读不互斥，读-写，写-写互斥）

它提供了getState()、setState(int) ,compareAndSetState(int, int) 三个方法来获取和修改单个原子状态的方法，在使用的是我，我们只需要重写以下几个方法即可，

tryAcquire(int) (独享模式锁)
tryRelease(int) （释放独享模式锁）
tryAcquireShared(int)（共享模式锁）
tryReleaseShared(int) （释放共享模式所）
isHeldExclusively() （判断是否是独享模式锁）

（三）源码实现

acquire：　　

　　根据调用流程acquire-release来一步步分析独享模式的源码，共享模式会在后面的学习中补上，首先从acquire,锁的入口开始。

public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

　　1)tryAcquire（int）最少会执行一次尝试去获取资源，如果获取到锁，则返回true,否则放回false。

protected boolean tryAcquire(int arg) {
        throw new UnsupportedOperationException();
    }

tryAcquire（int）在AQS源码中直接直接抛出了一个异常，这是因为我们前面说过AQS是一个框架，使用的时候是需要我们去实现自己的核心部分的，tryAcquire（int）这里调用的实际上是在使用时我们重写的方法，通过操作state
来进行我们自己的实现的。

　　2）addWaiter(Node.EXCLUSIVE)将一个独占模式的线程加入到队列中队尾。

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;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        enq(node);
        return node;
    }

这里的Node包含了当前线程本身以及线程的状态及以下基本信息，这里就直接看注释，我就不一一写出来了

/** Marker to indicate a node is waiting in shared mode */
        static final Node SHARED = new Node();
        /** Marker to indicate a node is waiting in exclusive mode */
        static final Node EXCLUSIVE = null;        /** waitStatus value to indicate thread has cancelled */
        static final int CANCELLED =  1;
        /** waitStatus value to indicate successor's thread needs unparking */
        static final int SIGNAL    = -1;
        /** waitStatus value to indicate thread is waiting on condition */
        static final int CONDITION = -2;
        /**
         * waitStatus value to indicate the next acquireShared should
         * unconditionally propagate
         */
        static final int PROPAGATE = -3;        /**
         * Status field, taking on only the values:
         *   SIGNAL:   值为-1，被标识为该等待唤醒状态的后继结点，当其前继结点的线程释放了同步锁或被取消，将会通知该后继结点的线程执行。说白了，就是处于唤醒状态，只要前继结点释放锁，就会通知标识为SIGNAL状态的后继结点的线程执行。
         *   CANCELLED: 值为1，在同步队列中等待的线程等待超时或被中断，需要从同步队列中取消该Node的结点，其结点的waitStatus为CANCELLED，即结束状态，进入该状态后的结点将不会再变化
         *   CONDITION: 值为-2，与Condition相关，该标识的结点处于等待队列中，结点的线程等待在Condition上，当其他线程调用了Condition的signal()方法后，CONDITION状态的结点将从等待队列转移到同步队列中，等待获取同步锁
　　　　　 *   PROPAGATE:  值为-3，与共享模式相关，在共享模式中，该状态标识结点的线程处于可运行状态。

　　这里特别说下一下0状态表示为初始化状态。

　　addWaiter()方法创建一个当前线程节点，当尾节点不为空时，将当前节点的prev指向双向链表的尾节点，并将当前节点通过cas的方式设置为尾节点，将尾节点的next指向当前节点，成功将整个链表连起来，这就是将当前线程加入到队列的过程，返回当前创建的节点。当尾节点为空时，调用enq方法。

　　enq(node)方法

private Node enq(final Node node) {
        for (;;) {
            Node t = tail;
            if (t == null) { // Must initialize
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }

　　for()循环表示自旋cas，知道成功将节点添加到队列为止，如果此时的尾节点tail为空，则创建一个空标志性的节点作为head节点，并将尾节点t也指向它，当tail不为空时，就按照前面的正常的添加节点的方式将当前节点添加到队列尾部。添加成功，退出循环，返回当前节点。

　　4）acquireQueued（）使线程在等待队列中获取资源，一直获取到资源后才返回。如果在整个等待过程中被中断过，则返回true，否则返回false。

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;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

　　当线程获取资源失败，并且已经进入了队列中了，那么此时的线程就需要等待了，只等待其他线程执行完成之后，再唤醒队列中的线程时，唤醒到该线程时，该线程才可以继续执行，failed标记线程是否拿到锁，interrupted标记线程是否被中断过。自旋获取锁，

　　第一步，拿到当前的上一个节点，即前驱，如果上一个节点是头节点，则有资格去获取锁，可能是上一个线程释放锁之后轮到第二个线程，当有资格获取锁时，将当前节点设置成头节点，此时前面的一个节点已经出了队列了，并将前一个节点置为空，为了方便垃圾回收，返回等待过程中该线程是否被中断过。

　　shouldParkAfterFailedAcquire（）这个方法，我们也需要理解一下：该方法主要是用于检查状态，判读自己是否可以进入等待队列。

 private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;
        if (ws == Node.SIGNAL)
            /*
             * This node has already set status asking a release
             * to signal it, so it can safely park.
             */
            return true;
　　
 
        if (ws > 0) {
            /*
             * Predecessor was cancelled. Skip over predecessors and
             * indicate retry.
             */
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
            /*
             * waitStatus must be 0 or PROPAGATE.  Indicate that we
             * need a signal, but don't park yet.  Caller will need to
             * retry to make sure it cannot acquire before parking.
             */
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }

　　从方法可以看到，当前节点的前一个节点的状态为通知状态时，返回true,即表示已经告诉了前节点，当释放之后叫醒当前节点，当ws大于0时，表示当前节点的线程被中断或者是等待超时，此时需要将该节点从队列中去除，即node.prev = pred = pred.prev和pred.next=node，表示将pred节点删除，替换成了pred的prev节点;else 则将pred节点设置成为通知唤醒状态。让前驱在执行完成后通知当前节点。

parkAndCheckInterrupt（）使线程真正的进入等待状态。

 private final boolean parkAndCheckInterrupt() {
        LockSupport.park(this);
        return Thread.interrupted();
    }

　　park()会让当前线程进入waiting状态。在此状态下，有两种途径可以唤醒该线程：1）被unpark()；2）被interrupt()，。需要注意的是，Thread.interrupted()会清除当前线程的中断标记位。

看了shouldParkAfterFailedAcquire()和parkAndCheckInterrupt()，现在让我们再回到acquireQueued()，总结下该函数的具体流程：

结点进入队尾后，检查状态，找到安全休息点；调用park()进入waiting状态，等待unpark()或interrupt()唤醒自己；被唤醒后，看自己是不是有资格能拿到号。如果拿到，head指向当前结点，并返回从入队到拿到号的整个过程中是否被中断过；如果没拿到，继续流程1。

release：
接下来看当线程释放锁，即Lock调用unlock时，源码情况：

public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

release的实现就相对简单了，首先同样是调用我们用户自己实现的tryRelease()方法，当tryReleace返回true时，判断头节点状态是否等于初始值，不等于初始值时调用unparkSuccessor(node)方法释放锁，否则表示资源已经呗释放，直接返回true。

unparkSuccessor（node）:

 private void unparkSuccessor(Node node) {
        /*
         * If status is negative (i.e., possibly needing signal) try
         * to clear in anticipation of signalling.  It is OK if this
         * fails or if status is changed by waiting thread.
         */
        int ws = node.waitStatus;
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);        /*
         * Thread to unpark is held in successor, which is normally
         * just the next node.  But if cancelled or apparently null,
         * traverse backwards from tail to find the actual
         * non-cancelled successor.
         */
        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);
    }

这个方法是用于唤醒一个线程，如果这个线程存在的话，ws小于0,表示当前线程是可以呗唤醒的，处于等待状态的线程，此时修改当前线程的状态为原始状态，如果当前线程的下一个线程为空，或者是状态大于0，表示处于CANCELLED状态，此时循环链表，找到最后一个状态小于0的线程，将找到的线程赋值给s,最后如果成功找到s，则使用unpark唤醒s节点的线程，这样就实现了release,

总结：release()是独占模式下线程释放共享资源的顶层入口。它会释放指定量的资源，如果彻底释放了（即state=0）,它会唤醒等待队列里的其他线程来获取资源。

（四）重写tryAcquire(int) 和 tryRelease(int) 方法实现一个简易的可重入锁

这里直接使用java文档的示例代码：

 class Mutex implements Lock, java.io.Serializable {    // Our internal helper class
    private static class Sync extends AbstractQueuedSynchronizer {
      // Report whether in locked state
      protected boolean isHeldExclusively() {
        return getState() == 1;
      }      // Acquire the lock if state is zero
      public boolean tryAcquire(int acquires) {
        assert acquires == 1; // Otherwise unused
       if (compareAndSetState(0, 1)) {
         setExclusiveOwnerThread(Thread.currentThread());
         return true;
       }
       return false;
      }      // Release the lock by setting state to zero
      protected boolean tryRelease(int releases) {
        assert releases == 1; // Otherwise unused
        if (getState() == 0) throw new IllegalMonitorStateException();
        setExclusiveOwnerThread(null);
        setState(0);
        return true;
      }      // Provide a Condition
      Condition newCondition() { return new ConditionObject(); }      // Deserialize properly
      private void readObject(ObjectInputStream s)
        throws IOException, ClassNotFoundException {
        s.defaultReadObject();
        setState(0); // reset to unlocked state
      }
    }// The sync object does all the hard work. We just forward to it.

    private final Sync sync = new Sync();    public void lock()                { sync.acquire(1); }
    public boolean tryLock()          { return sync.tryAcquire(1); }
    public void unlock()              { sync.release(1); }
    public Condition newCondition()   { return sync.newCondition(); }
    public boolean isLocked()         { return sync.isHeldExclusively(); }
    public boolean hasQueuedThreads() { return sync.hasQueuedThreads(); }
    public void lockInterruptibly() throws InterruptedException {
      sync.acquireInterruptibly(1);
    }
    public boolean tryLock(long timeout, TimeUnit unit)
        throws InterruptedException {
      return sync.tryAcquireNanos(1, unit.toNanos(timeout));
    }

由于官网的文档实现的是不可重入的锁，所以本人也自己实现了一个可重入锁，下面是代码：

package com.ucar.work;import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;/**
 * @since: 2018/9/27
 * @version: 1.0
 * Copyright: Copyright (c) 2018
 */
public class MyLock implements Lock, java.io.Serializable {    private static class Sync extends AbstractQueuedSynchronizer {
        @Override
        protected boolean isHeldExclusively() {
            return getState() == 1;
        }        @Override
        public boolean tryAcquire(int acquires) {
           int stat = getState();
           Thread thread = Thread.currentThread();
           //表示线程第一次进如，直接加锁
           if (stat == 0) {               compareAndSetState(0,stat+acquires);
               setExclusiveOwnerThread(thread);
               return true;
               //当前线程等于getExclusiveOwnerThread()表示线程重入。返回true表示可以获取锁
           } else if (stat != 0  && thread == getExclusiveOwnerThread()){
               return true;
           }
           //否则返回false表示获取锁失败
           return false;
        }        @Override
        protected boolean tryRelease(int releases) {
            int stat = getState();
            //stat==0表示该锁状态为释放状态，不能去释放
            if (stat == 0) {
                setExclusiveOwnerThread(null);
                return false;
            } else {
                //重入的情况下减去重入次数
                setState(getState()-releases);
            }
            //返回可释放信号
            return true;
        }        Condition newCondition() { return new ConditionObject(); }        private void readObject(ObjectInputStream s)
                throws IOException, ClassNotFoundException {
            s.defaultReadObject();
            setState(0);
        }
    }    private final Sync sync = new Sync();    @Override
    public void lock()                { sync.acquire(1); }
    @Override
    public boolean tryLock()          { return sync.tryAcquire(1); }
    @Override
    public void unlock()              { sync.release(1); }
    @Override
    public Condition newCondition()   { return sync.newCondition(); }
    public boolean isLocked()         { return sync.isHeldExclusively(); }
    public boolean hasQueuedThreads() { return sync.hasQueuedThreads(); }
    @Override
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }
    @Override
    public boolean tryLock(long timeout, TimeUnit unit)
            throws InterruptedException {
        return sync.tryAcquireNanos(1, unit.toNanos(timeout));
    }
}