AbstractQueuedSynchronizer的简单分析

最新推荐文章于 2023-02-13 20:18:52 发布

转载最新推荐文章于 2023-02-13 20:18:52 发布 · 96 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/qm-article/p/7955781.html

说明：本作者是文章的原创作者，转载请注明出处：本文地址：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方法时却不会阻塞，下面看这个类的示例代码

 1   public class TestLockSupport {
 2     
 3     
 4     public static void main(String[] args) {
 5         Thread threadA = new Thread(new Runnable() {
 6             
 7             @Override
 8             public void run() {
 9                 System.out.println("执行park方法前-------");//----1----
10                 //执行下面方法后threadA线程会阻塞
11                 LockSupport.park();
12                 System.out.println("执行park方法后-------");
13             }
14         });
15         
16         Thread threadB = new Thread(new Runnable() {
17             
18             @Override
19             public void run() {
20                 // TODO Auto-generated method stub
21                 System.out.println("执行unpark方法前-------");//----2----
22                 //给threadA颁发一个许可证
23                 LockSupport.unpark(threadA);
24                 try {
25                     Thread.sleep(1000);//这个作用是为了更好的演示
26                 } catch (InterruptedException e) {
27                     // TODO Auto-generated catch block
28                     e.printStackTrace();
29                 }
30                 System.out.println("执行unpark方法后-------");
31             }
32         });
33         
34         threadA.start();
35         threadB.start();
36     }
37 }

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

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

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

 1      public static void main(String[] args) {
 2         Thread threadA = new Thread(new Runnable() {
 3             @Override
 4             public void run() {
 5                 System.out.println("执行park方法前-------");//----1----
 6                 LockSupport.park();
 7                 LockSupport.park();
 8                 System.out.println("执行park方法后-------");
 9             }
10         });
11         
12         Thread threadB = new Thread(new Runnable() {
13             
14             @Override
15             public void run() {
16                 // TODO Auto-generated method stub
17                 System.out.println("执行unpark方法前-------");//----2----
18                 LockSupport.unpark(threadA);
19                 LockSupport.unpark(threadA);
20                 System.out.println("执行unpark方法后-------");
21             }
22         });
23         
24         threadA.start();
25         threadB.start();
26     }

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

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

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

三、AQS的源码简单分析

一、执行流程简述

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

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

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

二、内部类Node类简述

 1          //表明线程被取消了
 2          static final int CANCELLED =  1;
 3         /** waitStatus value to indicate successor's thread needs unparking 意思是，这个值代表着这个node节点的后继节点需要被唤醒*/
 4         static final int SIGNAL    = -1;
 5         /** waitStatus value to indicate thread is waiting on condition    意思是，该值代表线程在等待一个条件*/
 6         static final int CONDITION = -2;
 7         /**
 8          * waitStatus value to indicate the next acquireShared should   大致意思是，该值表明下一个需要被分享的节点应该无条件被分享
 9          * unconditionally propagate
10          */
11         static final int PROPAGATE = -3;

三、源码分析

　　3.1获取锁过程分析

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

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

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

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

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

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

 1      final boolean acquireQueued(final Node node, int arg) {
 2         boolean failed = true;  //失败标志
 3         try {
 4             boolean interrupted = false;//线程中断标志
 5             for (;;) {
 6                 final Node p = node.predecessor();//获取node的前一个节点
 7                 if (p == head && tryAcquire(arg)) {//若满足p是头结点，则尝试获取锁资源，
 8                     setHead(node);//将node设为头结点
 9                     p.next = null; // help GC
10                     failed = false;//将失败标志标位false
11                     return interrupted;
12                 }//获取锁失败后，进行挂起操作
13                 if (shouldParkAfterFailedAcquire(p, node) &&
14                     parkAndCheckInterrupt())
15                     interrupted = true;
16             }
17         } finally {
18             if (failed)//进行失败的处理逻辑
19                 cancelAcquire(node);
20         }
21     }

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

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

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

addWaiter（node）分析

 1 private Node addWaiter(Node mode) {
 2         Node node = new Node(Thread.currentThread(), mode);
 3         // Try the fast path of enq; backup to full enq on failure
 4         Node pred = tail;
 4         //作用是将node节点置为tail节点
 5         if (pred != null) {
 6             node.prev = pred;
 7             if (compareAndSetTail(pred, node)) {//执行成功表明node节点成功置为tail节点，若失败，可能是由其他的线程也在进行此操作，失败也不会在此一直等，会留到enq中等待
 8                 pred.next = node;
 9                 return node;
10             }
11         }
12         enq(node);//执行入队操作
13         return node;
14     }

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）

 1  private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
 2         int ws = pred.waitStatus;
 3         if (ws == Node.SIGNAL)
 4             /*
 5              * This node has already set status asking a release 当pred处于signal状态表这个节点请求释放
 6              * to signal it, so it can safely park.可以将这个节点挂起
 7              */
 8             return true;
 9         if (ws > 0) {
10             /* 表明pred节点被取消了，然后通过do-while循环去找状态小于0的节点
11              * Predecessor was cancelled. Skip over predecessors and
12              * indicate retry.
13              */
14             do {
15                 node.prev = pred = pred.prev;
16             } while (pred.waitStatus > 0);
17             pred.next = node;
18         } else {
19             /* 到了这里，表名这个状态值一定为0或propagate，之后把状态值设为signal
20              * 
21              * 
22              * 
23              */
24             compareAndSetWaitStatus(pred, ws, Node.SIGNAL);//
25         }
26         return false;
27     }

3.2，释放锁过程分析

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

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

unparkSuccessor的源码如下

 1     private void unparkSuccessor(Node node) {
 2         /* 如果node类中的的状态值是负数的话，（可能需要signal这个状态），
 3          * 尝试清除。若等待的线程的状态值被改变的话，就会失败，否则成功
 4          * If status is negative (i.e., possibly needing signal) try
 5          * to clear in anticipation of signalling.  It is OK if this
 6          * fails or if status is changed by waiting thread.
 7          */
 8         int ws = node.waitStatus;//获取node节点的状态值
 9         if (ws < 0)//小于0，则表明该node节点状态不是CANCELLED
10             //尝试交换ws和0的值，成功则true，否则代表着有其他线程已经改变了该node的状态值
11             compareAndSetWaitStatus(node, ws, 0);
12 
13         /*  unpark方法会在该节点后续节点中执行，通常情况下，下一个节点中，如果
14          *  节点状态值时CANCELLED或者为null，那么就从tail节点向前找状态值不是
15          *  CANCELLED的node节点
16          * Thread to unpark is held in successor, which is normally
17          * just the next node.  But if cancelled or apparently null,
18          * traverse backwards from tail to find the actual
19          * non-cancelled successor.
20          */
21         Node s = node.next;
22         if (s == null || s.waitStatus > 0) {
23             s = null;
24             通过for循环来寻找靠近node(也可理解为head)节点的节点(后者是状态值不是CANCELLED的节点)
25             for (Node t = tail; t != null && t != node; t = t.prev)
26                 if (t.waitStatus <= 0)
27                     s = t;
28         }
29         if (s != null)//找到了就给该node节点的线程一个通行证
30             LockSupport.unpark(s.thread);
31     }

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

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

转载于:https://www.cnblogs.com/qm-article/p/7955781.html

AbstractQueuedSynchronizer的简单分析

一、AbstractQueuedSynchronizer介绍

二、LockSupport

三、AQS的源码简单分析

一、执行流程简述

二、 内部类Node类简述

三、源码分析

3.1获取锁过程分析

3.2，释放锁过程分析

二、内部类Node类简述

　　3.1获取锁过程分析