二、同步工具类详解

1、Semaphore信号量:跟锁机制存在一定的相似性,semaphore也是一种锁机制,所不同的是,reentrantLock是只允许一个线程获得锁,而信号量持有多个许可(permits),允许多个线程获得许可并执行。可以用来控制同时访问某个特定资源的操作数量,或者同时执行某个指定操作的数量。

示例代码:

  1. 5 public class TIJ_semaphore {
  2. 6 public static void main(String[] args) {
  3. 7 ExecutorService exec = Executors.newCachedThreadPool();
  4. 8 final Semaphore semp = new Semaphore(5); // 5 permits
  5. 9
  6. 10 for (int index = 0; index < 20; index++) {
  7. 11 final int NO = index;
  8. 12 Runnable run = new Runnable() {
  9. 13 public void run() {
  10. 14 try {
  11. // if 1 permit avaliable, thread will get a permits and go; if no permit avaliable, thread will block until 1 avaliable
  12. 15 semp.acquire();
  13. 16 System.out.println("Accessing: " + NO);
  14. 17 Thread.sleep((long) (10000);
  15. 18 semp.release();
  16. 19 } catch (InterruptedException e) {
  17. 20 }
  18. 21 }
  19. 22 };
  20. 23 exec.execute(run);
  21. 24 }
  22. 25 exec.shutdown();
  23. 26 }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

2、CountDownLatch闭锁:允许一个或多个线程一直等待,直到其他线程的操作执行完后再执行。CountDownLatch是通过一个计数器来实现的,计数器的初始值为线程的数量。每当一个线程完成了自己的任务后,计数器的值就会减1。当计数器值到达0时,它表示所有的线程已经完成了任务,然后在闭锁上等待的线程就可以恢复执行任务。

主要方法: 
1. CountDownLatch.await():将某个线程阻塞住,直到计数器count=0才恢复执行。 
2. CountDownLatch.countDown():将计数器count减1。

使用场景: 
1. 实现最大的并行性:有时我们想同时启动多个线程,实现最大程度的并行性。例如,我们想测试一个单例类。如果我们创建一个初始计数为1的CountDownLatch,并让所有线程都在这个锁上等待,那么我们可以很轻松地完成测试。我们只需调用 一次countDown()方法就可以让所有的等待线程同时恢复执行。 
2. 开始执行前等待n个线程完成各自任务:例如应用程序启动类要确保在处理用户请求前,所有N个外部系统已经启动和运行了。 
3. 死锁检测:一个非常方便的使用场景是,你可以使用n个线程访问共享资源,在每次测试阶段的线程数目是不同的,并尝试产生死锁。 
4. 计算并发执行某个任务的耗时。

示例代码:

  1. public class CountDownLatchTest {
  2. public void timeTasks(int nThreads, final Runnable task) throws InterruptedException{
  3. final CountDownLatch startGate = new CountDownLatch(1);
  4. final CountDownLatch endGate = new CountDownLatch(nThreads);
  5. for(int i = 0; i < nThreads; i++){
  6. Thread t = new Thread(){
  7. public void run(){
  8. try{
  9. startGate.await();
  10. try{
  11. task.run();
  12. }finally{
  13. endGate.countDown();
  14. }
  15. }catch(InterruptedException ignored){
  16. }
  17. }
  18. };
  19. t.start();
  20. }
  21. long start = System.nanoTime();
  22. System.out.println("打开闭锁");
  23. startGate.countDown();
  24. endGate.await();
  25. long end = System.nanoTime();
  26. System.out.println("闭锁退出,共耗时" + (end-start));
  27. }
  28. public static void main(String[] args) throws InterruptedException{
  29. CountDownLatchTest test = new CountDownLatchTest();
  30. test.timeTasks(5, test.new RunnableTask());
  31. }
  32. class RunnableTask implements Runnable{
  33. @Override
  34. public void run() {
  35. System.out.println("当前线程为:" + Thread.currentThread().getName());
  36. }
  37. }
  38. 执行结果为:
  39. 打开闭锁
  40. 当前线程为:Thread-0
  41. 当前线程为:Thread-3
  42. 当前线程为:Thread-2
  43. 当前线程为:Thread-4
  44. 当前线程为:Thread-1
  45. 闭锁退出,共耗时1109195
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55

3、CyclicBarrier栅栏:用于阻塞一组线程直到某个事件发生。所有线程必须同时到达栅栏位置才能继续执行下一步操作,且能够被重置以达到重复利用。而闭锁是一次性对象,一旦进入终止状态,就不能被重置。

示例代码:

  1. public class CyclicBarrierTest {
  2. private final CyclicBarrier barrier;
  3. private final Worker[] workers;
  4. public CyclicBarrierTest(){
  5. int count = Runtime.getRuntime().availableProcessors();
  6. this.barrier = new CyclicBarrier(count,
  7. new Runnable(){
  8. @Override
  9. public void run() {
  10. System.out.println("所有线程均到达栅栏位置,开始下一轮计算");
  11. }
  12. });
  13. this.workers = new Worker[count];
  14. for(int i = 0; i< count;i++){
  15. workers[i] = new Worker(i);
  16. }
  17. }
  18. private class Worker implements Runnable{
  19. int i;
  20. public Worker(int i){
  21. this.i = i;
  22. }
  23. @Override
  24. public void run() {
  25. for(int index = 1; index < 3;index++){
  26. System.out.println("线程" + i + "第" + index + "次到达栅栏位置,等待其他线程到达");
  27. try {
  28. //注意是await,而不是wait
  29. barrier.await();
  30. } catch (InterruptedException e) {
  31. e.printStackTrace();
  32. return;
  33. } catch (BrokenBarrierException e) {
  34. e.printStackTrace();
  35. return;
  36. }
  37. }
  38. }
  39. }
  40. public void start(){
  41. for(int i=0;i<workers.length;i++){
  42. new Thread(workers[i]).start();
  43. }
  44. }
  45. public static void main(String[] args){
  46. new CyclicBarrierTest().start();
  47. }
  48. }
  49. 执行结果为:
  50. 线程01次到达栅栏位置,等待其他线程到达
  51. 线程11次到达栅栏位置,等待其他线程到达
  52. 线程21次到达栅栏位置,等待其他线程到达
  53. 线程31次到达栅栏位置,等待其他线程到达
  54. 所有线程均到达栅栏位置,开始下一轮计算
  55. 线程32次到达栅栏位置,等待其他线程到达
  56. 线程22次到达栅栏位置,等待其他线程到达
  57. 线程02次到达栅栏位置,等待其他线程到达
  58. 线程12次到达栅栏位置,等待其他线程到达
  59. 所有线程均到达栅栏位置,开始下一轮计算

Java并发包之闭锁/栅栏/信号量的更多相关文章

  1. Java并发包之闭锁/栅栏/信号量(转)

    本文转自http://blog.csdn.net/u010942020/article/details/79352560 感谢作者 一.Java多线程总结: 描述线程的类:Runable和Thread ...

  2. java并发编程笔记3-同步容器&并发容器&闭锁&栅栏&信号量

    一.同步容器: 1.Vector容器实现了List接口,Vector实际上就是一个数组,和ArrayList类似,但是Vector中的方法都是synchronized方法,即进行了同步措施.保证了线程 ...

  3. Java 并发包中的高级同步工具

    Java 并发包中的高级同步工具 Java 中的并发包指的是 java.util.concurrent(简称 JUC)包和其子包下的类和接口,它为 Java 的并发提供了各种功能支持,比如: 提供了线 ...

  4. java并发包&线程池原理分析&锁的深度化

          java并发包&线程池原理分析&锁的深度化 并发包 同步容器类 Vector与ArrayList区别 1.ArrayList是最常用的List实现类,内部是通过数组实现的, ...

  5. Java并发编程(您不知道的线程池操作), 最受欢迎的 8 位 Java 大师,Java并发包中的同步队列SynchronousQueue实现原理

    Java_并发编程培训 java并发程序设计教程 JUC Exchanger 一.概述 Exchanger 可以在对中对元素进行配对和交换的线程的同步点.每个线程将条目上的某个方法呈现给 exchan ...

  6. 深入浅出Java并发包—CountDownLauch原理分析 (转载)

    转载地址:http://yhjhappy234.blog.163.com/blog/static/3163283220135875759265/ CountDownLauch是Java并发包中的一个同 ...

  7. Java并发包源码学习系列:同步组件Semaphore源码解析

    目录 Semaphore概述及案例学习 类图结构及重要字段 void acquire() 非公平 公平策略 void acquire(int permits) void acquireUninterr ...

  8. Java并发包源码学习之AQS框架(四)AbstractQueuedSynchronizer源码分析

    经过前面几篇文章的铺垫,今天我们终于要看看AQS的庐山真面目了,建议第一次看AbstractQueuedSynchronizer 类源码的朋友可以先看下我前面几篇文章: <Java并发包源码学习 ...

  9. Java并发包源码学习之AQS框架(三)LockSupport和interrupt

    接着上一篇文章今天我们来介绍下LockSupport和Java中线程的中断(interrupt). 其实除了LockSupport,Java之初就有Object对象的wait和notify方法可以实现 ...

随机推荐

  1. Laravel artisan commands

    使用php artisan list 可以看到artisan的所有命令以及选项. 当然你也可以在此基础上扩展自己的命令. 1. key 1.1 key:generate 这是一个加密秘钥,用于保证安全 ...

  2. IE7下面iframe滚动条无法用鼠标轮滚 其他浏览器可以

    1.让 IFRAME 隐藏滚动条,通常的做法就是在嵌入  IFRAME 的页面的 CSS 中指定以下规则:   html, body {overflow: hidden}   2.如果只是想隐藏横向滚 ...

  3. 16:django 有条件的视图处理(Last-Modified和ETag)&&加密签名

    有条件的视图处理 上一节我们介绍了缓存来减轻服务器的负担,这里的有条件的视图处理也从一定程度上减轻了服务器的负担,在正式介绍之前,先来看两个概念:Last-Modified和ETag Last-Mod ...

  4. 《逐梦旅程 WINDOWS游戏编程之从零开始》笔记4——Direct3D编程基础

    第11章 Direct3D编程基础 2D游戏是贴图的艺术,3D游戏是渲染的艺术.这句话在我学过了之前的GDI编程之后,前一句算是有所体会,现在是来理解后一句的时候了. 安装DirectX SDK配置啥 ...

  5. hdu 1533(最小费用最大流)

    Going Home Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)Total ...

  6. win10更换登陆背景和关闭锁屏

    更换登陆背景图 用国外一个hacker写的工具,可在github上下载,或者下载我上传到百度网盘的备份.win10默认的登陆背景太难看了. 去掉锁屏图片 登陆界面其实本身就是一种锁屏,为什么还要单独搞 ...

  7. Guid is not updated for cluster with specified cluster id; need to wait for hosts in this cluster to come up

    http://mail-archives.apache.org/mod_mbox/cloudstack-users/201306.mbox/%3c201306181058330006472@gmail ...

  8. hdu5728

    详细题解: http://blog.csdn.net/wust_zzwh/article/details/51966450 ……化简公式的能力还不够啊…… #include<bits/stdc+ ...

  9. 两个线程交替打印奇偶数【Lock版】

    import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public clas ...

  10. 洛谷P1129 [ZJOI2007] 矩阵游戏

    题目传送门 分析:看到这题呢,首先想到的就是搜索,数据范围也不大嘛.但是仔细思考发现这题用搜索很难做,看了大佬们的题解后学到了,这一类题目要用二分图匹配来做.可以知道,如果想要的话,每一个子都可以移动 ...