AbstractQueuedSynchronizer的简单分析

说明：本作者是文章的原创作者，转载请注明出处：本文地址：http://www.cnblogs.com/qm-article/p/7955781.html

一、AbstractQueuedSynchronizer介绍

AbstractQueuedSynchronizer(以下简称AQS)，它提供了一套完整的同步框架，比如常用的ReentrantLock、countdownLatch等一些类都继承了该抽像类，像之前博文中的线程池里也有它的是实现类，它的实现类如下

二、LockSupport

在分析AQS之前，先简单的了解下LockSupport这个类，先看看API文档的解释

先介绍这个类里的2个核心静态方法

1、park，使用LockSupport.park会阻塞当前线程，其作用类似于Object的wait方法。

2、unpark  该方法的的参数是Thread，使用LockSupport.unpark(thread)，会给thread线程一个许可证(也可以理解为通行证)，作用类似于notify方法

上述两个方法与Object的wait和notify类似，但也有不同之处，首先park和unpark不会抛异常，二、park与unpark的使用位置可以颠倒，这么说吧，我们在使用wait和notify，一般都是一个线程先wait，之后由notify去唤醒，然而park和unpark不一样，当某个线程执行park方法时，会查看有没有许可证，没有则阻塞，有则通，在执行unpark方法时，会向该参数的线程办法一个许可证，之后那个线程就拥有许可证，当遇到park方法时不会阻塞。当然如果某线程事先已经获取了许可证(即执行了unpark方法，参数为该线程)，那么当该线程再次执行park方法时却不会阻塞，下面看这个类的示例代码

   public class TestLockSupport {

     public static void main(String[] args) {
         Thread threadA = new Thread(new Runnable() {

             @Override
             public void run() {
                 System.out.println("执行park方法前-------");//----1----
                 //执行下面方法后threadA线程会阻塞
                 LockSupport.park();
                 System.out.println("执行park方法后-------");
             }
         });

         Thread threadB = new Thread(new Runnable() {

             @Override
             public void run() {
                 // TODO Auto-generated method stub
                 System.out.println("执行unpark方法前-------");//----2----
                 //给threadA颁发一个许可证
                 LockSupport.unpark(threadA);
                 try {
                     Thread.sleep(1000);//这个作用是为了更好的演示
                 } catch (InterruptedException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                 }
                 System.out.println("执行unpark方法后-------");
             }
         });

         threadA.start();
         threadB.start();
     }
 }

执行结果如下(结果并不唯一）

执行park方法前-------
执行unpark方法前-------
执行park方法后-------
执行unpark方法后-------

值得注意的是，一个线程只能拥有一个许可证，简单的说就是当线程A内执行n(n>1)个park方法，你在线程B内也执行n个unpark(线程A)，按照正常理解，线程A内不会阻塞，但不巧的是，它阻塞了，示例代码如下

      public static void main(String[] args) {
         Thread threadA = new Thread(new Runnable() {
             @Override
             public void run() {
                 System.out.println("执行park方法前-------");//----1----
                 LockSupport.park();
                 LockSupport.park();
                 System.out.println("执行park方法后-------");
             }
         });

         Thread threadB = new Thread(new Runnable() {

             @Override
             public void run() {
                 // TODO Auto-generated method stub
                 System.out.println("执行unpark方法前-------");//----2----
                 LockSupport.unpark(threadA);
                 LockSupport.unpark(threadA);
                 System.out.println("执行unpark方法后-------");
             }
         });

         threadA.start();
         threadB.start();
     }

这个无论执行多少次，那句   "执行Park方法后----"，不会执行，因为被阻塞了

根据这个类的特性表明也可以用来控制线程的执行顺序

这个类的其他方法介绍如下

三、AQS的源码简单分析

一、执行流程简述

AQS它的整体流程分为获取锁和释放锁这两个主要流程

1、获取锁的过程：当执行acquire(int)方法时，会以独占模式去获取资源，当获取锁资源成功时，则进入临界区，等待线程调度执行，若失败，则会进入一个队列                                          中，等待被唤醒出队操作

2、释放锁的过程：在执行release(int)方法时，会去释放锁的资源，如果没有其他线程在等待锁资源(即获取锁资源)，则释放完成，若有，则去唤醒队列中的头结点

二、 内部类Node类简述

          //表明线程被取消了
          static final int CANCELLED =  1;
         /** waitStatus value to indicate successor's thread needs unparking 意思是，这个值代表着这个node节点的后继节点需要被唤醒*/
         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;

三、源码分析

　　3.1获取锁过程分析

　　  在了解acquire(int)方法前，先来了解其内部要用到的两个方法tryAcquire(int)和acquireQueued(Node,int)

　　1、tryAcquire(int)源码如下，它的作用就是尝试去获取锁资源，获取成功，则返回true，获取失败返回true

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

咦，怎么会抛异常，是的你没看错，这是AQS内部的tryAcquire(int)方法，因为该类是个抽象类，当继承该类时，要去重写tryAcquire(int)方法，至于它为啥不去弄一个个抽象方法，这个还真不知道！！！它需要AQS子类去自行实现获取锁资源的代码，关于它的某个实现，你也可以去看看前面一片博文的介绍

<ThreadPoolExecutor的分析(二)>中的worker类。

2、acquireQueued(Node,int)源码如下

      final boolean acquireQueued(final Node node, int arg) {
         boolean failed = true;  //失败标志
         try {
             boolean interrupted = false;//线程中断标志
             for (;;) {
                 final Node p = node.predecessor();//获取node的前一个节点
                 if (p == head && tryAcquire(arg)) {//若满足p是头结点，则尝试获取锁资源，
                     setHead(node);//将node设为头结点
                     p.next = null; // help GC
                     failed = false;//将失败标志标位false
                     return interrupted;
                 }//获取锁失败后，进行挂起操作
                 if (shouldParkAfterFailedAcquire(p, node) &&
                     parkAndCheckInterrupt())
                     interrupted = true;
             }
         } finally {
             if (failed)//进行失败的处理逻辑
                 cancelAcquire(node);
         }
     }

先来了解下acquire(int)方法，其源码如下　

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

当执行该方法时，会先去调用tryAcquire(int)方法来尝试获取所资源，若成功，则进入临界区，若失败，则执行acquireQueued方法，当其返回true，则执行selfInterrupt方法，即中断当前线程。

addWaiter（node）分析

 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;
 4         //作用是将node节点置为tail节点
         if (pred != null) {
             node.prev = pred;
             if (compareAndSetTail(pred, node)) {//执行成功表明node节点成功置为tail节点，若失败，可能是由其他的线程也在进行此操作，失败也不会在此一直等，会留到enq中等待
                 pred.next = node;
                 return node;
             }
         }
         enq(node);//执行入队操作
         return node;
     }

enq(node)分析

 1       private Node enq(final Node node) {
 2     　　//通过for循环来讲node节点置为tail节点，有那种不成功不回头的决心
 3         for (;;) {
 4             Node t = tail;
 5             if (t == null) { // Must initialize
 6 　　　　　　　　　　//初始化头结点
 7                 if (compareAndSetHead(new Node()))
 8                     tail = head;
 9             } else {
10                 node.prev = t;
11 　　　　　　　　　　//执行成功表明node节点成功置为tail节点，若失败，可能是由其他的线程也在进行此操作
12                 if (compareAndSetTail(t, node)) {
13                     t.next = node;
14                     return t;
15                 }
16             }
17         }
18     }

shouldParkAfterFailAcquire（node,node）

  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 当pred处于signal状态表这个节点请求释放
              * to signal it, so it can safely park.可以将这个节点挂起
              */
             return true;
         if (ws > 0) {
             /* 表明pred节点被取消了，然后通过do-while循环去找状态小于0的节点
              * Predecessor was cancelled. Skip over predecessors and
              * indicate retry.
              */
             do {
                 node.prev = pred = pred.prev;
             } while (pred.waitStatus > 0);
             pred.next = node;
         } else {
             /* 到了这里，表名这个状态值一定为0或propagate，之后把状态值设为signal
              *
              *
              *
              */
             compareAndSetWaitStatus(pred, ws, Node.SIGNAL);//
         }
         return false;
     }

3.2，释放锁过程分析

一、前面也说到在执行释放的时候，会先去通过tryRelease(int)获取锁资源，若成功，则之后通过unparkSuccessor来进行具体的释放操作

其中tryRelease也是一个需要子类去实现的方法。

unparkSuccessor的源码如下

     private void unparkSuccessor(Node node) {
         /* 如果node类中的的状态值是负数的话，（可能需要signal这个状态），
          * 尝试清除。若等待的线程的状态值被改变的话，就会失败，否则成功
          * 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;//获取node节点的状态值
         if (ws < )//小于0，则表明该node节点状态不是CANCELLED
             //尝试交换ws和0的值，成功则true，否则代表着有其他线程已经改变了该node的状态值
             compareAndSetWaitStatus(node, ws, );

         /*  unpark方法会在该节点后续节点中执行，通常情况下，下一个节点中，如果
          *  节点状态值时CANCELLED或者为null，那么就从tail节点向前找状态值不是
          *  CANCELLED的node节点
          * 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 > ) {
             s = null;
             通过for循环来寻找靠近node(也可理解为head)节点的节点(后者是状态值不是CANCELLED的节点)
             for (Node t = tail; t != null && t != node; t = t.prev)
                 if (t.waitStatus <= )
                     s = t;
         }
         if (s != null)//找到了就给该node节点的线程一个通行证
             LockSupport.unpark(s.thread);
     }

总结：以上就是AQS的源码解析，及涉及到的代码及相应的逻辑，当然上面的一些结论是很浅的一些。

(对于以上结论，是本人自己研究和结合网上的一些知识写出来的，仅供参考，若有不足之处，还请指出)