AQS原理探究

AQS原理探究

AQS维持了一个单一的原子变量--state,通过getState、setState、compareAndSetState可以操作它的值。

• 对于重入锁ReentrantLock的实现来说，state可以用来表示当前线程获取锁的可重入次数
• 对于读写锁ReentrantReadWriteLock来说，state的高16位表示获取该读锁的次数，低16位表示获取该写锁的次数
• 对于信号量Semaphore来说，state表示当前可用信号的次数
• 对于FutuerTask来说，state表示任务状态（还没开始、运行、完成、取消）
• 对于CountDownLatch和CyclicBarrier来说，state用来表示计算器当前的值

AQS结点

AQS是一个FIFO的双向队列。

  static final class Node {
        /** Marker to indicate a node is waiting in shared mode */
        //共享模式，标记该线程是获取共享资源时候被阻塞后挂起放入AQS队列
        static final Node SHARED = new Node()；
        /** Marker to indicate a node is waiting in exclusive mode */
        //独占模式：标记该线程是获取独占资源时候被阻塞挂起放入AQS队列
        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;
         /**
         * The field is initialized to 0 for normal sync nodes, and
         * CONDITION for condition nodes.  It is modified using CAS
         * (or when possible, unconditional volatile writes).
         */
        /**
        * 记录当前线程的状态：
        * signal: 线程需要被唤醒（unpark）
        * cancelled：线程被取消了（due to timeout or interrupt）
        * condition：线程在队列里等待
        * propagate 释放共享资源时候需要通知其他结点
        */
        volatile int waitStatus;
        
        //记录当前结点的前驱结点
        volatile Node prev;

        //记录当前结点的后继结点
        volatile Node next;
        
        //存入放入AQS队列中的线程
        volatile Thread thread;

        //存储condition队列中的后继节点。
        //若nextWaiter=SHAERD，则CLH队列是 独享锁 队列
        //如nextWaiter=EXCLUSIVE(null),则CLH为 共享锁 队列
        Node nextWaiter;

        /**
         * Returns true if node is waiting in shared mode.
         */
        //共享锁返回true
        final boolean isShared() {
            return nextWaiter == SHARED;
        }

        //获取前驱结点 
        final Node predecessor() throws NullPointerException {
            Node p = prev;
            if (p == null)  //null则抛出NullPointerException
                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; //mode表示是独享锁还是共享锁
            this.thread = thread; //结点对应的线程
        }

        Node(Thread thread, int waitStatus) { // Used by Condition
            this.waitStatus = waitStatus; //线程的等待状态
            this.thread = thread;   //结点对应的线程
        }
    }

AQS内部类ConditionObject

ConditionObejct是用来结合锁实现线程同步，其可直接访问AQS对象内部的变量，如state、AQS队列；ConditionObejct是条件变量，每个条件变量对应着一个条件队列（单向链表队列），用来存放调用条件变量的await()方法后被阻塞的线程。

• 独占模式下获取和释放资源的方法

  void acquire(int arg)

  void acquireInterruptibly(int arg)

  boolean release(int arg)

  /**
  * 当一个线程调用acquire()方法来获取多占资源的时候，
  * 1.调用tryAcquire尝试获取资源
  * 2. 具体是设置状态变量state的值(原子操作UnSafe类实现)，成功则直接返回，失败则将当前线程封装为类型为Node.Exclusive的Node结点后插入到AQS阻塞队列尾部
  * 3.调用
  *
  */
  public final void acquire(int arg) {
          if (!tryAcquire(arg) &&
              acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
              selfInterrupt();
      }
      
  public final void acquireInterruptibly(int arg)
              throws InterruptedException {
          if (Thread.interrupted())
              throw new InterruptedException();
          if (!tryAcquire(arg))
              doAcquireInterruptibly(arg);
      }
  //释放锁    
  public final boolean release(int arg) {
          if (tryRelease(arg)) {
              Node h = head;
              if (h != null && h.waitStatus != 0)
                  //唤醒结点
                  unparkSuccessor(h);
              return true;
          }
          return false;
      }
  

acquire深入分析

//线程尝试获得锁，如果成功就直接返回，不成功则创建一个Node结点并添加到CLH队列中。TryAcquire尝试获得锁，addWriter则创建节点并添加到CLH到队列中。其中tryAcquire并没有实现，仅仅是抛出一个异常，需要锁自己实现
protected boolean tryAcquire(int arg) {
    throw new UnsupportedOperationException();
}

//产生一个中断。
static void selfInterrupt() {
    Thread.currentThread().interrupt();
}
//主要是根据该结点找到CLH的头节点，并尝试获得锁，判断是否需要挂起，并返回挂起标识。
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);
        }
    }

• 共享状态下获取和释放资源的方法

  void acquire(int arg)

  void acquireInterruptibly(int arg)

  boolean release(int arg)

      public final void acquireShared(int arg) {
          if (tryAcquireShared(arg) < 0)
              doAcquireShared(arg);
      }
      public final void acquireSharedInterruptibly(int arg)
              throws InterruptedException {
          if (Thread.interrupted())
              throw new InterruptedException();
          if (tryAcquireShared(arg) < 0)
              doAcquireSharedInterruptibly(arg);
      }
     public final boolean releaseShared(int arg) {
          if (tryReleaseShared(arg)) {
              doReleaseShared();
              return true;
          }
          return false;
      }