10张图详解管程内部，进去看看

java对共享变量的操作管理使用了MESA管程模型。下图是Java基于AQS实现的MESA管程模型：

让客户满意是我们工作的目标，不断超越客户的期望值来自于我们对这个行业的热爱。我们立志把好的技术通过有效、简单的方式提供给客户，将通过不懈努力成为客户在信息化领域值得信任、有价值的长期合作伙伴，公司提供的服务项目有：域名与空间、网络空间、营销软件、网站建设、惠水网站维护、网站推广。

上图中有三个知识点：

  • MESA管程模型封装了共享变量和对共享变量的操作，线程要进入管程内部，必须获取到锁，如果获取锁失败就进入入口等待队列阻塞等待。
  • 如果线程获取到锁，就进入到管程内部。但是进入到管程内部，也不一定能立刻操作共享变量，而是要看条件变量是否满足，如果不满足，只能进入条件变量等待队列阻塞等待。
  • 在条件变量等待队列中，如果被其他线程唤醒，也不一定能立刻操作共享变量，而是需要去入口等待队列重新排队等待获取锁。

本文主要讲解管程模型中条件变量等待队列。

1 官方示例

首先我们看一下官方给出的示例代码：

 
 
 
 
    
  
  
  
  
  1. public class BoundedBuffer { 
    2. 
  
  
  
  
  2.     final Lock lock = new ReentrantLock(); 
    3. 
  
  
  
  
  3.     final Condition notFull  = lock.newCondition(); 
    4. 
  
  
  
  
  4.     final Condition notEmpty = lock.newCondition(); 
    5. 
  
  
  
  
  5.     final Object[] items = new Object[100]; 
    6. 
  
  
  
  
  6.     int putptr, takeptr, count; 
    7. 
  
  
  
  
  7.  
    8. 
  
  
  
  
  8.     public void put(Object x) throws InterruptedException { 
    9. 
  
  
  
  
  9.         lock.lock(); 
    10. 
  
  
  
  
  10.         try { 
    11. 
  
  
  
  
  11.             while (count == items.length) 
    12. 
  
  
  
  
  12.                 notFull.await(); 
    13. 
  
  
  
  
  13.             items[putptr] = x; 
    14. 
  
  
  
  
  14.             if (++putptr == items.length) putptr = 0; 
    15. 
  
  
  
  
  15.             ++count; 
    16. 
  
  
  
  
  16.             notEmpty.signal(); 
    17. 
  
  
  
  
  17.         } finally { 
    18. 
  
  
  
  
  18.             lock.unlock(); 
    19. 
  
  
  
  
  19.         } 
    20. 
  
  
  
  
  20.     } 
    21. 
  
  
  
  
  21.  
    22. 
  
  
  
  
  22.     public Object take() throws InterruptedException { 
    23. 
  
  
  
  
  23.         lock.lock(); 
    24. 
  
  
  
  
  24.         try { 
    25. 
  
  
  
  
  25.             while (count == 0) 
    26. 
  
  
  
  
  26.                 notEmpty.await(); 
    27. 
  
  
  
  
  27.             Object x = items[takeptr]; 
    28. 
  
  
  
  
  28.             if (++takeptr == items.length) takeptr = 0; 
    29. 
  
  
  
  
  29.             --count; 
    30. 
  
  
  
  
  30.             notFull.signal(); 
    31. 
  
  
  
  
  31.             return x; 
    32. 
  
  
  
  
  32.         } finally { 
    33. 
  
  
  
  
  33.             lock.unlock(); 
    34. 
  
  
  
  
  34.         } 
    35. 
  
  
  
  
  35.     } 
    36. 
  
  
  
  
  36. } 
    37.

这个代码定义了两个条件变量，notFull和notEmpty，说明如下：

  • 如果items数组已经满了，则notFull变量不满足，线程需要进入notFull条件等待队列进行等待。当take方法取走一个数组元素时，notFull条件满足了，唤醒notFull条件等待队列中等待线程。
  • 如果items数组为空，则notEmpty变量不满足，线程需要进入notEmpty条件等待队列进行等待。当put方法加入一个数组元素时，notEmpty条件满足了，唤醒notEmpty条件等待队列中等待线程。
  • 条件变量是绑定在Lock上的，示例代码使用了ReentrantLock。在执行await和signal方法时首先要获取到锁。

2 原理简介

Java AQS的条件变量等待队列是基于接口Condition和ConditionObject来实现的，URM类图如下：

Condition接口主要定义了下面3个方法：

  • await：进入条件等待队列
  • signal：唤醒条件等待队列中的元素
  • signalAll：唤醒条件等待队列中的所有元素

3 await

条件等待队列跟入口等待队列有两个不同：

  • 虽然二者共用了Node类，但是条件等待队列是单向队列，入口等待队列是双向队列，条件队列中下一个节点的引用是nextWaiter，入口等待队列中下一个节点的引用是next。
  • 条件等待队列中元素的waitStatus必须是-2。

await方法的流程如下图：

3.1 进入条件等待队列

入队方法对应方法addConditionWaiter，这里有三种情况：

  • 队列为空，则新建一个节点，如下图：

  • 队列非空，最后一个元素的waitStatus是-2，如下图：

  • 队列非空，最后一个元素的waitStatus不是-2，如下图：

可以看到，这种情况会从队列第一个元素开始检查waitStatus不是-2的元素，并从队列中移除。

3.2 释放锁

AQS的并发锁是基于state变量实现的，线程进入条件等待队列后，要释放锁，即state会变为0，释放操作会唤醒入口等待队列中的线程。对应方法fullyRelease，返回值是释放锁减掉的state值savedState。

3.3 阻塞等待

释放锁后，线程阻塞，自旋等待被唤醒。

3.4 唤醒之后

唤醒之后，当前线程主要有四个动作：

  • 转入入口等待队列，并把waitStatus改为0。

waitStatus等于0表示中间状态，当前节点后面的节点已经唤醒，但是当前节点线程还没有执行完成。

  • 重新获取锁，如果获取成功，则当前线程成为入口等待队列头结点，interruptMode置为1。
  • 如果当前节点在条件等待队列中有后继节点，则剔除条件等待队列中waitStatus!=-2的节点，即队列中状态为取消的节点。
  • interruptMode如果不等于0，则处理中断。

3.5 一个细节

上面提到了interruptMode，这个属性有三个值：

  • 0：没有被中断
  • -1：中断后抛出InterruptedException，这种情况是当前线程阻塞，没有被signal之前发生了中断
  • 1：重新进入中断状态，这种情况是指当前线程阻塞，被signal之后发生了中断

3.6 扩展

AQS还提供了其他几个await方法，如下：

  • awaitUninterruptibly：不用处理中断。
  • awaitNanos：自旋等待唤醒过程中有超时时间限制，超时则转入入口等待队列。
  • awaitUntil：自旋等待唤醒过程中有截止时间，时间到则转入入口等待队列。

4 signal

唤醒条件等待队列中的元素，首先判断当前线程是否持有独占锁，如果没有，抛出异常。

唤醒条件队列中的元素，会从第一个元素也就是firstWaiter开始，根据firstWaiter的waitStatus是不是-2，分两种情况。

4.1 waitStatus==-2

条件队列第一个节点进入入口等待队列，等待获取锁，如下图：

这里有两个注意点：

  • 如果入口等待队列中tail节点的waitStatus小于等于0，则firstWaiter加入后需要把旧tail节点置为-1(表示后面节点等待当前节点唤醒)，如下图：

如果重置waitStatus状态失败,则unpark节点firstWaiter。

  • 如果入口等待队列中tail节点的waitStatus大于0，则unpark节点firstWaiter。

4.2 waitStatus!=-2

如果firstWaiter的waitStatus不等于-2，则查找firstWaiter的nextWaiter，直到找到一个waitStatus等于-2的节点，然后将这个节点加入入口等待队列队尾，如下图：

4.3 waitStatus修改

上面的两种情况无论哪种，进入入口等待队列之前都要用CAS的方式把waitStatus改为0。

5 signalAll

理解了signal的逻辑，signalAll的逻辑就非常容易理解了。首先判断当前线程是否持有独占锁，如果没有，抛出异常。

将条件等待队列中的所有节点依次加入入口等待队列。如下图：

6 使用案例

6.1 示例代码

java并发包下有很多类使用到了AQS中的Condition，如下图：

这里我们以CyclicBarrier为例来讲解。CyclicBarrier是让一组线程相互等待共同达到一个屏障点。从Cyclic可以看出Barrier可以循环利用，也就是当线程释放之后可以继续使用。

看下面这段示例代码：

 
 
 
 
    
  
  
  
  
  1. public static void main(String[] args) { 
    2. 
  
  
  
  
  2.     CyclicBarrier cyclicBarrier = new CyclicBarrier(2, () -> { 
    3. 
  
  
  
  
  3.         System.out.println("栅栏中的线程执行完成"); 
    4. 
  
  
  
  
  4.     }); 
    5. 
  
  
  
  
  5.     ExecutorService executorService = Executors.newFixedThreadPool(2); 
    6. 
  
  
  
  
  6.  
    7. 
  
  
  
  
  7.     executorService.submit(() -> { 
    8. 
  
  
  
  
  8.         try { 
    9. 
  
  
  
  
  9.             System.out.println("线程1：" + Thread.currentThread().getName()); 
    10. 
  
  
  
  
  10.             cyclicBarrier.await(); 
    11. 
  
  
  
  
  11.         } catch (Exception e) { 
    12. 
  
  
  
  
  12.             e.printStackTrace(); 
    13. 
  
  
  
  
  13.         } 
    14. 
  
  
  
  
  14.     }); 
    15. 
  
  
  
  
  15.  
    16. 
  
  
  
  
  16.     executorService.submit(() -> { 
    17. 
  
  
  
  
  17.         try { 
    18. 
  
  
  
  
  18.             System.out.println("线程2：" + Thread.currentThread().getName()); 
    19. 
  
  
  
  
  19.             cyclicBarrier.await(); 
    20. 
  
  
  
  
  20.         } catch (Exception e) { 
    21. 
  
  
  
  
  21.             e.printStackTrace(); 
    22. 
  
  
  
  
  22.         } 
    23. 
  
  
  
  
  23.     }); 
    24. 
  
  
  
  
  24.  
    25. 
  
  
  
  
  25.     executorService.shutdown(); 
    26. 
  
  
  
  
  26. } 
    27.

执行结果：

 
 
 
 
    
  
  
  
  
  1. 线程1：pool-1-thread-1 
    2. 
  
  
  
  
  2. 线程2：pool-1-thread-2 
    3. 
  
  
  
  
  3. 栅栏中的线程执行完成 
    4.

6.2 原理讲解

CyclicBarrier初始化的时候，会指定线程的数量count，每个线程执行完逻辑后，调用CyclicBarrier的await方法，这个方法首先将count减1，然后调用Condition的await，让当前线程进入条件等待队列。当最后一个线程将count减1后，count数量等于0，这时就会调用Condition的signalAll方法唤醒所有线程。

7 总结

java的管程模型使用了MESA模型，基于AQS实现的MESA模型中，使用双向队列实现了入口等待队列，使用变量state实现了并发锁，使用Condition实现了条件等待队列。

在AQS的实现中，使用同步队列这个术语来表示双向队列，本文中使用入口等待队列来描述是为了更好的配合管程模型来讲解。

AQS的Condition中，使用await方法将当前线程放入条件等待队列阻塞等待，使用notify来唤醒条件等待队列中的线程，被唤醒之后，线程并不能立刻执行，而是进入入口等待队列等待获取锁。

当前文章：10张图详解管程内部，进去看看
链接分享：http://www.shufengxianlan.com/qtweb/news22/224572.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

域名注册知识

同城分类信息

成都商城网站建设　　 　成都封阳台　　 　广安网站制作公司　　 　成都品牌网站设计　　 　成都网站推广　　 　重庆网站建设　　 　成都手机网站报价　　 　青年旅行社　　 　成都网站运维　　 　抖音代运营　　 　成都印刷厂　　 　简阳服务器托管　　 　国泰民安消防　　 　微信开发　　 　物流公司网站建设方案　　 　内江网站建设　　 　泸县网站建设　　 　重庆机房托管　　 　成都网站设计　　 　崇州湖霆科技