多线程并发库高级应用之其它同步工具类

最新推荐文章于 2021-08-26 19:15:48 发布

DarkNight_YuJiang

最新推荐文章于 2021-08-26 19:15:48 发布

阅读量652

点赞数

分类专栏：多线程文章标签：库 SynchronousQueue 并发

多线程专栏收录该内容

14 篇文章 0 订阅

订阅专栏

目录(?)[+]

笔记摘要：

这里主要介绍了java5中线程锁技术以外的其他同步工具，首先介绍semaphore：一个计数信号量。用于控制同时访问资源的线程个数，

CyclicBarrier同步辅助类：从字面意思看是路障，这里用于线程之间的相互等待，到达某点后，继续向下执行，CountDownLatch同步辅

助类：在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。犹如倒计时计数器，然后是Exchangeer：实现两个

对象之间数据交换，可阻塞队列：ArrayBlockingQueue，通过阻塞队列间的通信来演示其作用，最后介绍了几个同步集合。

一、Semaphore实现信号灯

1.、Semaphore可以维护当前访问自身的线程个数，并提供了同步机制，使用Semaphore可以控制同时访问资源的线程个数，例如，实现一个文件允许

的并发访问数。Semaphore 只对可用许可的号码进行计数，并采取相应的行动。

2、Semaphore实现的功能就像：银行办理业务，一共有5个窗口，但一共有10个客户，一次性最多有5个客户可以进行办理，其他的人必须等候，

当5个客户中的任何一个离开后，在等待的客户中有一个人可以进行业务办理。

3、Semaphore提供了两种规则：

一种是公平的：获得资源的先后，按照排队的先后。在构造函数中设置true实现

一种是野蛮的：谁有本事抢到资源，谁就可以获得资源的使用权。

4、与传统的互斥锁的异同：

单个信号量的Semaphore对象可以实现互斥锁的功能，并且可以是由一个线程获得了“锁“，再由另外一个线程释放”锁“，

这可以应用于死锁恢复的一些场合。

5、应用场景：共享资源的争夺，例如游戏中选手进入房间的情况。

[java]view plaincopy 
    
 import java.util.concurrent.ExecutorService;  
 import java.util.concurrent.Executors;  
 import java.util.concurrent.Semaphore;  
   
 public class SemaphoreTest {  
     public static void main(String[] args) {  
           
 　　//创建一个可根据需要创建新线程的线程池  
 　　ExecutorService service = Executors.newCachedThreadPool();  
         final  Semaphore sp = new Semaphore(3);  
           
 　　//创建10个线程  
 　　for(int i=0;i<10;i++){  
             Runnable runnable = new Runnable(){  
                     public void run(){  
                     try {  
                         sp.acquire();   //获取灯，即许可权  
                     } catch (InterruptedException e1) {  
                         e1.printStackTrace();  
                     }  
                     System.out.println("线程" + Thread.currentThread().getName() +   
                             "进入，当前已有" + (3-sp.availablePermits()) + "个并发");  
                     try {  
                         Thread.sleep((long)(Math.random()*10000));  
                     } catch (InterruptedException e) {  
                         e.printStackTrace();  
                     }  
                     System.out.println("线程" + Thread.currentThread().getName() +   
                             "即将离开");                      
                     sp.release();   // 释放一个许可，将其返回给信号量  
   
                     //下面代码有时候执行不准确，因为其没有和上面的代码合成原子单元  
                     System.out.println("线程" + Thread.currentThread().getName() +   
                             "已离开，当前已有" + (3-sp.availablePermits()) + "个并发");                      
                 }  
             };  
             service.execute(runnable);            
         }  
     }  
   
 }  

二、其他同步工具类：

CyclicBarrier

1、一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，

这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用，所以称它为循环的 barrier。

2、CyclicBarrier 支持一个可选的 Runnable 命令，在一组线程中的最后一个线程到达之后（但在释放所有线程之前），该命令只在每个屏障

点运行一次。若在继续所有参与线程之前更新共享状态，此屏障操作很有用。

示例:

3个线程到达某个集合点后再向下执行,使用await方法实现

[java]view plaincopy 
    
 import java.util.concurrent.CyclicBarrier;  
 import java.util.concurrent.ExecutorService;  
 import java.util.concurrent.Executors;  
   
 public class CyclicBarrierTest {  
   
     public static void main(String[] args) {  
         ExecutorService service = Executors.newCachedThreadPool();  
         final  CyclicBarrier cb = new CyclicBarrier(3);  
         for(int i=0;i<3;i++){  
             Runnable runnable = new Runnable(){  
                     public void run(){  
                     try {  
                         Thread.sleep((long)(Math.random()*10000));    
                         System.out.println("线程" + Thread.currentThread().getName() +   
                                 "即将到达集合地点1，当前已有" + (cb.getNumberWaiting()+1) + "个已经到达，" + (cb.getNumberWaiting()==2?"都到齐了，继续走啊":"正在等候"));                         
                         cb.await();//在所有参与者都已经在此 barrier 上调用 await 方法之前，将一直等待。  
                           
                         Thread.sleep((long)(Math.random()*10000));    
                         System.out.println("线程" + Thread.currentThread().getName() +   
                                 "即将到达集合地点2，当前已有" + (cb.getNumberWaiting()+1) + "个已经到达，" + (cb.getNumberWaiting()==2?"都到齐了，继续走啊":"正在等候"));  
                         cb.await();   
                         Thread.sleep((long)(Math.random()*10000));    
                         System.out.println("线程" + Thread.currentThread().getName() +   
                                 "即将到达集合地点3，当前已有" + (cb.getNumberWaiting() + 1) + "个已经到达，" + (cb.getNumberWaiting()==2?"都到齐了，继续走啊":"正在等候"));                       
                         cb.await();                       
                     } catch (Exception e) {  
                         e.printStackTrace();  
                     }                 
                 }  
             };  
             service.execute(runnable);  
         }  
         service.shutdown();  
     }  
 }  

CountDownLatch

1、一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。犹如倒计时计数器，调用CountDownLatch对象

的countDown方法就将计数器减1，当计数到达0时，则所有等待者或单个等待者开始执行。

2、可以实现一个人（也可以是多个人）等待其他所有人都来通知他，也可以实现一个人通知多个人的效果，类似裁判一声口令，运动员开始奔跑

（一对多），或者所有运送员都跑到终点后裁判才可以公布结果（多对一）。

3、用指定的计数初始化 CountDownLatch。在调用 countDown() 方法之前，await 方法会一直受阻塞。之后，会释放所有等待的线程，await 的所

有后续调用都将立即返回。这种现象只出现一次——计数无法被重置。如果需要重置计数，请考虑使用 CyclicBarrier。

示例：

实现运动员比赛的效果

[java]view plaincopy 
    
 import java.util.concurrent.CountDownLatch;  
 import java.util.concurrent.CyclicBarrier;  
 import java.util.concurrent.ExecutorService;  
 import java.util.concurrent.Executors;  
   
 public class CountdownLatchTest {  
   
     public static void main(String[] args) {  
           
 　　ExecutorService service = Executors.newCachedThreadPool();  
 　　  
 　　//构造一个用给定计数初始化的 CountDownLatch,相当于裁判的口哨  
 　　final CountDownLatch cdOrder = new CountDownLatch(1);  
 　　  
 　　//相当于定义3个运行员  
         final CountDownLatch cdAnswer = new CountDownLatch(3);  
         for (int i = 0; i < 3; i++) {  
             Runnable runnable = new Runnable() {  
                 public void run() {  
                     try {  
                         System.out.println("线程"  
                                 + Thread.currentThread().getName() + "正准备接受命令");  
   
                         // 等待发令枪  
                         cdOrder.await();//使当前线程在锁存器倒计数至零之前一直等待  
   
                         System.out.println("线程"  
                                 + Thread.currentThread().getName() + "已接受命令");  
                         Thread.sleep((long) (Math.random() * 10000));  
                         System.out  
                                 .println("线程"  
                                         + Thread.currentThread().getName()  
                                         + "回应命令处理结果");  
   
                         // 各个运动员完报告成绩之后，通知裁判  
                         cdAnswer.countDown();//递减锁存器的计数，如果计数到达零，则释放所有等待的线程  
   
                     } catch (Exception e) {  
                         e.printStackTrace();  
                     }  
                 }  
             };  
             service.execute(runnable);  
         }  
         try {  
             Thread.sleep((long) (Math.random() * 10000));  
   
             System.out.println("线程" + Thread.currentThread().getName()  
                     + "即将发布命令");  
             // 发令枪打响，比赛开始  
             cdOrder.countDown();  
   
             System.out.println("线程" + Thread.currentThread().getName()  
                     + "已发送命令，正在等待结果");  
   
             // 裁判等待各个运动员的结果  
             cdAnswer.await();  
   
             // 裁判公布获得所有运动员的成绩  
             System.out.println("线程" + Thread.currentThread().getName()  
                     + "已收到所有响应结果");  
         } catch (Exception e) {  
             e.printStackTrace();  
         }  
         service.shutdown();  
   
     }  
 }  

Exchanger

1、用于实现两个对象之间的数据交换，每个对象在完成一定的事务后想与对方交换数据，第一个先拿出数据的对象将一直等待第二个对象拿着数据

到来时，彼此才能交换数据。

2、方法：exchange（V x）

等待另一个线程到达此交换点（除非当前线程被中断），然后将给定的对象传送给该线程，并接收该线程的对象。

3、应用：使用 Exchanger 在线程间交换缓冲区

示例：

模拟毒品交易情景

[java]view plaincopy 
    
 import java.util.concurrent.Exchanger;  
 import java.util.concurrent.ExecutorService;  
 import java.util.concurrent.Executors;  
   
 public class ExchangerTest {  
   
     public static void main(String[] args) {  
         ExecutorService service = Executors.newCachedThreadPool();  
         final Exchanger exchanger = new Exchanger();  
         service.execute(new Runnable(){  
             public void run() {  
                 try {                 
   
                     String data1 = "毒品";  
                     System.out.println("线程" + Thread.currentThread().getName() +   
                     "正在把: " + data1 +"   交易出去");  
                     Thread.sleep((long)(Math.random()*10000));  
                     String data2 = (String)exchanger.exchange(data1);  
                     System.out.println("线程" + Thread.currentThread().getName() +   
                     "换得了: " + data2);  
                 }catch(Exception e){  
                       
                 }  
             }     
         });  
         service.execute(new Runnable(){  
             public void run() {  
                 try {                 
   
                     String data1 = "美金";  
                     System.out.println("线程" + Thread.currentThread().getName() +   
                     "正在把: " + data1 +"   交易出去");  
                     Thread.sleep((long)(Math.random()*10000));                    
                     String data2 = (String)exchanger.exchange(data1);  
                     System.out.println("线程" + Thread.currentThread().getName() +   
                     "换得了: " + data2);  
                 }catch(Exception e){  
                       
                 }                 
             }     
         });       
     }  
 }  

ArrayBlockingQueue

1、一个由数组支持的有界阻塞队列。此队列按 FIFO（先进先出）原则对元素进行排序。队列包含固定长度的队列和不固定长度的队列。

这是一个典型的“有界缓存区”，固定大小的数组在其中保持生产者插入的元素和使用者提取的元素。一旦创建了这样的缓存区，就不能

再增加其容量。试图向已满队列中放入元素会导致操作受阻塞；试图从空队列中提取元素将导致类似阻塞。

通俗的讲：

当指定队列大小，如果已经放满，其他存入数据的线程就阻塞，等着该队列中有空位，才能放进去。当取的比较快，队列中没有数据，

取数据的线程阻塞，等队列中放入了数据，才可以取。

2、ArrayBlockingQueue中只有put和take方法才具有阻塞功能。方法类型如下

	抛出异常	特殊值	阻塞	超时
插入	add(e)	offer(e)	put(e)	offer(e, time, unit)
移除	remove()	poll()	take()	poll(time, unit)
检查	element()	peek()	不可用	不可用

示例：

用3个空间的队列来演示向阻塞队列中存取数据的效果。

[java]view plaincopy 
    
 通俗的将：  
 当指定队列大小，如果已经放满，其他存入数据的线程就阻塞，等着该队列中有空位，才能放进去。当取的比较快，队列中没有数据，取数据的线程阻塞，等队列中放入了数据，才可以取。  
   
   
 ArrayBlockingQueue中只有put和take方法才具有阻塞功能。方法类型如下  
   
     抛出异常    特殊值 阻塞  超时  
 插入  add(e)  offer(e)    put(e)  offer(e, time, unit)  
 移除  remove()    poll()  take()  poll(time, unit)  
 检查  element()   peek()  不可用 不可用  
   
 用3个空间的队列来演示向阻塞队列中存取数据的效果。  
   
 package cn.xushuai.thread;  
 import java.util.concurrent.ArrayBlockingQueue;  
 import java.util.concurrent.BlockingQueue;  
   
 public class BlockingQueueTest {  
     public static void main(String[] args) {  
         final BlockingQueue queue = new ArrayBlockingQueue(3);  
         for(int i=0;i<2;i++){  
             new Thread(){  
                 public void run(){  
                     while(true){  
                         try {  
                             Thread.sleep((long)(Math.random()*1000));  
                             System.out.println(Thread.currentThread().getName() + "准备放数据!");                              
                             queue.put(1);   //放进去后，可能立即执行“准备取数据”  
                             System.out.println(Thread.currentThread().getName() + "已经放了数据，" +                             
                                         "队列目前有" + queue.size() + "个数据");  
                         } catch (InterruptedException e) {  
                             e.printStackTrace();  
                         }  
   
                     }  
                 }  
                   
             }.start();  
         }  
           
         new Thread(){  
             public void run(){  
                 while(true){  
                     try {  
                         //将此处的睡眠时间分别改为100和1000，观察运行结果  
                         Thread.sleep(1000);  
                         System.out.println(Thread.currentThread().getName() + "准备取数据!");  
                         queue.take();   //取出后可能來不及执行下面的打印语句，就跑到了“准备放数据”，  
                         System.out.println(Thread.currentThread().getName() + "已经取走数据，" +                             
                                 "队列目前有" + queue.size() + "个数据");                      
                     } catch (InterruptedException e) {  
                         e.printStackTrace();  
                     }  
                 }  
             }  
         }.start();            
     }  
 }  

阻塞队列间的通信

A队列向空间中存数据，B从空间里取数据，A存入后，通知B去取，B取过之后，通知A去放，依次循环

示例：

子线程先循环10次，接着主线程循环100次，接着又回到子线程，循环10次，再回到主线程又循环100，如此循环50次。

说明：

这里通过使用两个具有1个空间的队列来实现同步通知的功能（实现了锁和condition的功能），以便实现队列间的通信，其中使用到了

构造代码块为主队列先存入一个数据，以使其先阻塞，子队列先执行。

使用构造代码块的原因：

成员变量在创建类的实例对象时，才分配空间，才能有值，所以创建一个构造方法来给main_quene赋值，这里不可以使用静态代码块，因为静态

在还没创建对象就存在，而sub_quene和main_quene是对象创建以后的成员变量，所以这里用匿名构造方法，它的运行时期在任何构造方法之前，

创建几个对象就执行几次

[java]view plaincopy 
    
 import java.util.concurrent.ArrayBlockingQueue;  
 import java.util.concurrent.BlockingQueue;  
   
 public class BlockingQueueCommunication {  
     public static void main(String[] args){  
           
         final Business business = new Business();  
           
         new Thread(new Runnable(){  
             @Override  
             public void run() {  
                 for(int i=1;i<=50;i++){  
                     business.sub(i);  
                 }  
             }  
         }).start();  
   
             //主线程外部循环  
             for(int i=1;i<=50;i++){  
                 business.main(i);  
           }  
        }  
   
     //业务类  
     static class Business{  
           
         BlockingQueue<Integer> sub_quene = new ArrayBlockingQueue<Integer>(1);  
         BlockingQueue<Integer> main_quene = new ArrayBlockingQueue<Integer>(1);  
                   
         {  
 　　//为了让子队列先走，所以在一开始就往主队列中存入一个对象，使其阻塞。  
             try {  
                 main_quene.put(1);    
             } catch (InterruptedException e) {  
                 e.printStackTrace();  
             }         
         }  
           
         //子队列先走       
         public  void sub(int i){  
               
             try {  
                 sub_quene.put(1);   //子队列第一次存入，可以执行，但由于只有1个空间，已经存满，所以只有在执行后要等到take之后才能继续下次执行  
             } catch (InterruptedException e) {  
                 e.printStackTrace();  
             }  
             //子队列循环执行  
             for(int j=1;j<=10;j++){  
                 System.out.println("sub thread sequence of"+i+",loop of "+j);  
             }  
             try {  
                 main_quene.take();  //让主队列从已经填满的队列中取出数据，使其开始第一次执行  
             } catch (InterruptedException e) {  
                 e.printStackTrace();  
             }  
         }  
           
         public void main(int i){  
               
             try {  
                 main_quene.put(1);  //主队列先前放过1个空间，现在处于阻塞状态，等待子队列通知，即子线程中的main_quene.take();   
             } catch (InterruptedException e) {  
                 e.printStackTrace();  
             }  
               
 　　//主队列循环执行  
             for(int j=1;j<=100;j++){  
                 System.out.println("main thread sequence of"+i+", loop of "+j);  
             }     
             try {  
                 sub_quene.take(); //让子队列从已经填满的队列中取出数据，使其执行  
             } catch (InterruptedException e) {  
                 e.printStackTrace();  
             }  
         }     
     }  
    }  