多线程与并发----CycliBarrier、CountDownLatch 和 Exchanger同步

浅浅的花香味﹌ 2021-09-15 10:20 370阅读 0赞

**一、CycliBarrier**

**        表示大家彼此等待，大家集合号后才开始出发，分散活动后又在指定地点集合碰面，**这就好比整个公司的人员利用周末时间集体郊游一样，先各自从家出发到公司集合后，在他同时出发到公园游玩，在指定地点集合后再同时就餐。

**功能：**

一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用，所以称它为循环 的 barrier。

CyclicBarrier 支持一个可选的 Runnable 命令，在一组线程中的最后一个线程到达之后（但在释放所有线程之前），该命令只在每个屏障点运行一次。若在继续所有参与线程之前更新共享状态，此*屏障操作* 很有用。

> > <table style="width:421.3pt;margin-left:2.4pt;border:none;"> 
> > <tbody> 
> > <tr> 
> > <td colspan="2" style="width:421.3pt;padding:2.25pt 2.25pt 2.25pt 2.25pt;border-left:1pt outset;border-right:1pt outset;border-top:1pt outset;border-bottom:1pt outset;background:rgb(204,204,255);">构造方法摘要</td> 
> > </tr> 
> > <tr> 
> > <td colspan="2" style="width:421.3pt;padding:2.25pt 2.25pt 2.25pt 2.25pt;border-left:1pt outset;border-right:1pt outset;border-top:none;border-bottom:1pt outset;background:rgb(255,255,255);"><a rel="nofollow">CyclicBarrier</a>(int&nbsp;parties) &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;创建一个新的 CyclicBarrier，它将在给定数量的参与者（线程）处于等待状态时启动，但它不会在启动 barrier 时执行预定义的操作。</td> 
> > </tr> 
> > <tr> 
> > <td colspan="2" style="width:421.3pt;padding:2.25pt;border-left:1pt outset;border-right:1pt outset;border-top:none;border-bottom:1pt outset;"><a rel="nofollow">CyclicBarrier</a>(int&nbsp;parties, <a title="java.lang 中的接口" rel="nofollow">Runnable</a>&nbsp;barrierAction) &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;创建一个新的 CyclicBarrier，它将在给定数量的参与者（线程）处于等待状态时启动，并在启动 barrier 时执行给定的屏障操作，该操作由最后一个进入 barrier 的线程执行。</td> 
> > </tr> 
> > <tr> 
> > <td colspan="2" style="width:421.3pt;padding:2.25pt 2.25pt 2.25pt 2.25pt;border-left:1pt outset;border-right:1pt outset;border-top:none;border-bottom:1pt outset;background:rgb(204,204,255);">方法摘要</td> 
> > </tr> 
> > <tr> 
> > <td style="width:41.9pt;padding:2.25pt;border-left:1pt outset;border-right:1pt outset;border-top:none;border-bottom:1pt outset;">&nbsp;int</td> 
> > <td style="width:379.4pt;padding:2.25pt;border-left:none;border-right:1pt outset;border-top:1pt outset;border-bottom:1pt outset;"><a rel="nofollow">await</a>() &nbsp;&nbsp;&nbsp;&nbsp;在所有<a rel="nofollow">参与者</a>都已经在此 barrier 上调用 await 方法之前，将一直等待。</td> 
> > </tr> 
> > <tr> 
> > <td style="width:41.9pt;padding:2.25pt 2.25pt 2.25pt 2.25pt;border-left:1pt outset;border-right:1pt outset;border-top:none;border-bottom:1pt outset;background:rgb(255,255,255);">&nbsp;int</td> 
> > <td style="width:379.4pt;padding:2.25pt 2.25pt 2.25pt 2.25pt;border-left:none;border-right:1pt outset;border-top:none;border-bottom:1pt outset;background:rgb(255,255,255);"><a rel="nofollow">await</a>(long&nbsp;timeout, <a title="java.util.concurrent 中的枚举" rel="nofollow">TimeUnit</a>&nbsp;unit) &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;在所有<a rel="nofollow">参与者</a>都已经在此屏障上调用 await 方法之前将一直等待,或者超出了指定的等待时间。</td> 
> > </tr> 
> > <tr> 
> > <td style="width:41.9pt;padding:2.25pt;border-left:1pt outset;border-right:1pt outset;border-top:none;border-bottom:1pt outset;">&nbsp;int</td> 
> > <td style="width:379.4pt;padding:2.25pt;border-left:none;border-right:1pt outset;border-top:none;border-bottom:1pt outset;"><a rel="nofollow">getNumberWaiting</a>() &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;返回当前在屏障处等待的参与者数目。</td> 
> > </tr> 
> > <tr> 
> > <td style="width:41.9pt;padding:2.25pt 2.25pt 2.25pt 2.25pt;border-left:1pt outset;border-right:1pt outset;border-top:none;border-bottom:1pt outset;background:rgb(255,255,255);">&nbsp;int</td> 
> > <td style="width:379.4pt;padding:2.25pt 2.25pt 2.25pt 2.25pt;border-left:none;border-right:1pt outset;border-top:none;border-bottom:1pt outset;background:rgb(255,255,255);"><a rel="nofollow">getParties</a>() &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;返回要求启动此 barrier 的参与者数目。</td> 
> > </tr> 
> > <tr> 
> > <td style="width:41.9pt;padding:2.25pt;border-left:1pt outset;border-right:1pt outset;border-top:none;border-bottom:1pt outset;">&nbsp;boolean</td> 
> > <td style="width:379.4pt;padding:2.25pt;border-left:none;border-right:1pt outset;border-top:none;border-bottom:1pt outset;"><a rel="nofollow">isBroken</a>() &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;查询此屏障是否处于损坏状态。</td> 
> > </tr> 
> > <tr> 
> > <td style="width:41.9pt;padding:2.25pt 2.25pt 2.25pt 2.25pt;border-left:1pt outset;border-right:1pt outset;border-top:none;border-bottom:1pt outset;background:rgb(255,255,255);">&nbsp;void</td> 
> > <td style="width:379.4pt;padding:2.25pt 2.25pt 2.25pt 2.25pt;border-left:none;border-right:1pt outset;border-top:none;border-bottom:1pt outset;background:rgb(255,255,255);"><a rel="nofollow">reset</a>() &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;将屏障重置为其初始状态。</td> 
> > </tr> 
> > </tbody> 
> > </table>
> 
> **示例代码：**

> > import java.util.concurrent.CyclicBarrier;
> > import java.util.concurrent.ExecutorService;
> > import java.util.concurrent.Executors;
> > 
> > public class CylicBarrierTest {
> > 
> > 	public static void main(String[] args) {
> > 		ExecutorService service = Executors.newCachedThreadPool();
> > 		final CyclicBarrier cb = new CyclicBarrier(3); //约定3个人
> > 		for (int i=0; i<3; i++)//产生3个人
> > 		{	
> > 			//每个人的任务
> > 			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();//到了其他人没来就等人到齐了再继续进行
> > 						
> > 						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();
> > 	}
> > }

> > **运行结果为：**

> > > 线程 pool-1-thread-1 即将到达集合地点1，当前已有 1 个到达， 正在等候
> > > 
> > > 线程 pool-1-thread-2 即将到达集合地点1，当前已有 2 个到达， 正在等候
> > > 
> > > 线程 pool-1-thread-3 即将到达集合地点1，当前已有 3 个到达， 都到齐了，继续走啊 
> > > 
> > > 线程 pool-1-thread-3 即将到达集合地点2，当前已有 1 个到达， 正在等候 
> > > 
> > > 线程 pool-1-thread-1 即将到达集合地点2，当前已有 2 个到达， 正在等候 
> > > 
> > > 线程 pool-1-thread-2 即将到达集合地点2，当前已有 3 个到达， 都到齐了，继续走啊** **

**二、CountDownLatch**

** 1、功能：**

**好像倒计时计数器，调用CountDownLatch对象的countDown方法就将计数器减 1，当到达 0 时，所有等待着就开始执行。**

**  2、原理**

** java.util.concurrent.CountDownLatch**

一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。 用给定的*计数* 初始化 CountDownLatch。由于调用了 countDown() 方法，所以在当前计数到达零之前，await 方法会一直受阻塞。之后，会释放所有等待的线程，await 的所有后续调用都将立即返回。这种现象只出现一次——计数无法被重置。如果需要重置计数，请考虑使用 CyclicBarrier。

CountDownLatch 是一个通用同步工具，它有很多用途。将计数 1 初始化的 CountDownLatch 用作一个简单的开/关锁存器，或入口：在通过调用 countDown() 的线程打开入口前，所有调用await 的线程都一直在入口处等待。用*N* 初始化的 CountDownLatch 可以使一个线程在 *N* 个线程完成某项操作之前一直等待，或者使其在某项操作完成 N 次之前一直等待。

CountDownLatch 的一个有用特性是，它不要求调用 countDown 方法的线程等到计数到达零时才继续，而在所有线程都能通过之前，它只是阻止任何线程继续通过一个 await。

> > > <table style="width:421.3pt;margin-left:2.4pt;border:none;"> 
> > > <tbody> 
> > > <tr> 
> > > <td colspan="2" style="width:421.3pt;padding:2.25pt 2.25pt 2.25pt 2.25pt;border-left:1pt outset;border-right:1pt outset;border-top:1pt outset;border-bottom:1pt outset;background:rgb(204,204,255);">构造方法摘要</td> 
> > > </tr> 
> > > <tr> 
> > > <td colspan="2" style="width:421.3pt;padding:2.25pt 2.25pt 2.25pt 2.25pt;border-left:1pt outset;border-right:1pt outset;border-top:none;border-bottom:1pt outset;background:rgb(255,255,255);"><a rel="nofollow">CountDownLatch</a>(int&nbsp;count) &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;构造一个用给定计数初始化的 CountDownLatch。</td> 
> > > </tr> 
> > > <tr> 
> > > <td colspan="2" style="width:421.3pt;padding:2.25pt 2.25pt 2.25pt 2.25pt;border-left:1pt outset;border-right:1pt outset;border-top:none;border-bottom:1pt outset;background:rgb(204,204,255);">方法摘要</td> 
> > > </tr> 
> > > <tr> 
> > > <td style="width:41.9pt;padding:2.25pt 2.25pt 2.25pt 2.25pt;border-left:1pt outset;border-right:1pt outset;border-top:none;border-bottom:1pt outset;background:rgb(255,255,255);">&nbsp;void</td> 
> > > <td style="width:379.4pt;padding:2.25pt 2.25pt 2.25pt 2.25pt;border-left:none;border-right:1pt outset;border-top:1pt outset;border-bottom:1pt outset;background:rgb(255,255,255);"><a rel="nofollow">await</a>() &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;使当前线程在锁存器倒计数至零之前一直等待，除非线程被<a rel="nofollow">中断</a>。</td> 
> > > </tr> 
> > > <tr> 
> > > <td style="width:41.9pt;padding:2.25pt;border-left:1pt outset;border-right:1pt outset;border-top:none;border-bottom:1pt outset;">&nbsp;boolean</td> 
> > > <td style="width:379.4pt;padding:2.25pt;border-left:none;border-right:1pt outset;border-top:none;border-bottom:1pt outset;"><a rel="nofollow">await</a>(long&nbsp;timeout, <a title="java.util.concurrent 中的枚举" rel="nofollow">TimeUnit</a>&nbsp;unit) &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;使当前线程在锁存器倒计数至零之前一直等待，除非线程被<a rel="nofollow">中断</a>或超出了指定的等待时间。</td> 
> > > </tr> 
> > > <tr> 
> > > <td style="width:41.9pt;padding:2.25pt 2.25pt 2.25pt 2.25pt;border-left:1pt outset;border-right:1pt outset;border-top:none;border-bottom:1pt outset;background:rgb(255,255,255);">&nbsp;void</td> 
> > > <td style="width:379.4pt;padding:2.25pt 2.25pt 2.25pt 2.25pt;border-left:none;border-right:1pt outset;border-top:none;border-bottom:1pt outset;background:rgb(255,255,255);"><a rel="nofollow">countDown</a>() &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;递减锁存器的计数，如果计数到达零，则释放所有等待的线程。</td> 
> > > </tr> 
> > > <tr> 
> > > <td style="width:41.9pt;padding:2.25pt;border-left:1pt outset;border-right:1pt outset;border-top:none;border-bottom:1pt outset;">&nbsp;long</td> 
> > > <td style="width:379.4pt;padding:2.25pt;border-left:none;border-right:1pt outset;border-top:none;border-bottom:1pt outset;"><a rel="nofollow">getCount</a>() &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;返回当前计数。</td> 
> > > </tr> 
> > > <tr> 
> > > <td style="width:41.9pt;padding:2.25pt 2.25pt 2.25pt 2.25pt;border-left:1pt outset;border-right:1pt outset;border-top:none;border-bottom:1pt outset;background:rgb(255,255,255);">&nbsp;<a title="java.lang 中的类" rel="nofollow">String</a></td> 
> > > <td style="width:379.4pt;padding:2.25pt 2.25pt 2.25pt 2.25pt;border-left:none;border-right:1pt outset;border-top:none;border-bottom:1pt outset;background:rgb(255,255,255);"><a rel="nofollow">toString</a>() &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;返回标识此锁存器及其状态的字符串。</td> 
> > > </tr> 
> > > </tbody> 
> > > </table>

**示例代码：*****多个运动员等待裁判命令：裁判等所有运动员到齐后发布结果***

> > import java.util.concurrent.CountDownLatch;
> > import java.util.concurrent.ExecutorService;
> > import java.util.concurrent.Executors;
> > 
> > public class CountdownLatchTest {
> > 
> > 	public static void main(String[] args) {
> > 		
> > 		ExecutorService service = Executors.newCachedThreadPool();
> > 		
> > 		//裁判发布命令的计数器，计数器为0，运动员就跑
> > 		final CountDownLatch cdOrder = new CountDownLatch(1);	
> > 		
> > 		//运动员跑到终点的计数器，为0裁判宣布结果
> > 		final CountDownLatch cdAnswer = new CountDownLatch(3);
> > 		
> > 		//产生3个运动员
> > 		for (int i=0; i<3; i++)
> > 		{	//运动员的任务
> > 			Runnable runnable = new Runnable(){
> > 			public void run()
> > 			{
> > 				try {
> > 					System.out.println("线程"+Thread.currentThread().getName()+"正准备接受命令");
> > 					
> > 					//等待发布命令
> > 					cdOrder.await();	//计数器为0继续向下执行
> > 					System.out.println("线程"+Thread.currentThread().getName()+"已接受命令");
> > 					
> > 					Thread.sleep((long)(Math.random()*10000));//开始跑步
> > 					System.out.println("线程"+Thread.currentThread().getName()+"回应命令处理结果");
> > 					cdAnswer.countDown();//跑到终点了，计数器减1
> > 				} catch (Exception e) {
> > 					e.printStackTrace();
> > 				}
> > 			}
> > 		};
> > 			service.execute(runnable);//运动员开始任务
> > 		}
> > 		try {
> > 			Thread.sleep((long)(Math.random()*10000));//开始跑步
> > 			System.out.println("线程"+Thread.currentThread().getName()+"即将发布命令");
> > 			cdOrder.countDown();//跑到终点了，计数器减1
> > 			System.out.println("线程"+Thread.currentThread().getName()+"已发送命令，正在等待结果");
> > 			cdAnswer.await();
> > 			System.out.println("线程"+Thread.currentThread().getName()+"已收到所有响应结果");
> > 			
> > 		} catch (Exception e) {
> > 			e.printStackTrace();
> > 		}
> > 		service.shutdown();
> > 	}
> > }

> **运行结果为：**

> > 线程pool-1-thread-2正准备接受命令
> > 
> > 线程pool-1-thread-3正准备接受命令
> > 
> > 线程pool-1-thread-1正准备接受命令
> > 
> > 线程main即将发布命令
> > 
> > 线程main已发送命令，正在等待结果
> > 
> > 线程pool-1-thread-1已接受命令
> > 
> > 线程pool-1-thread-2已接受命令
> > 
> > 线程pool-1-thread-3已接受命令
> > 
> > 线程pool-1-thread-3回应命令处理结果
> > 
> > 线程pool-1-thread-1回应命令处理结果
> > 
> > 线程pool-1-thread-2回应命令处理结果
> > 
> > 线程main已收到所有响应结果
> > 
> >   
> >

**三、Exchanger**

**        1、功能**

**            用于实现两个人之间的数据交换，每个人在完成一定的事务后想与对方交换数据，第一个先拿出数据的人会一直等待第二个人，直到第二个人拿着数据到来时，才能彼此交换数据。**

**        2、原理**

**         ** java.util.concurrent.Exchanger<V> V - 可以交换的对象类型

可以在对中对元素进行配对和交换的线程的同步点。每个线程将条目上的某个方法呈现给exchange 方法，与伙伴线程进行匹配，并且在返回时接收其伙伴的对象。Exchanger 可能被视为 SynchronousQueue 的双向形式。Exchanger 可能在应用程序（比如遗传算法和管道设计）中很有用。

> > > <table style="width:416pt;margin-left:2.4pt;border:none;"> 
> > > <tbody> 
> > > <tr> 
> > > <td colspan="2" style="width:416pt;padding:2.25pt 2.25pt 2.25pt 2.25pt;border-left:1pt outset;border-right:1pt outset;border-top:1pt outset;border-bottom:1pt outset;background:rgb(204,204,255);">构造方法摘要</td> 
> > > </tr> 
> > > <tr> 
> > > <td colspan="2" style="width:416pt;padding:2.25pt 2.25pt 2.25pt 2.25pt;border-left:1pt outset;border-right:1pt outset;border-top:none;border-bottom:1pt outset;background:rgb(255,255,255);"><a rel="nofollow">Exchanger</a>() &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;创建一个新的 Exchanger。</td> 
> > > </tr> 
> > > <tr> 
> > > <td colspan="2" style="width:416pt;padding:2.25pt 2.25pt 2.25pt 2.25pt;border-left:1pt outset;border-right:1pt outset;border-top:none;border-bottom:1pt outset;background:rgb(204,204,255);">方法摘要</td> 
> > > </tr> 
> > > <tr> 
> > > <td style="width:16.05pt;padding:2.25pt 2.25pt 2.25pt 2.25pt;border-left:1pt outset;border-right:1pt outset;border-top:none;border-bottom:1pt outset;background:rgb(255,255,255);">&nbsp;<a title="Exchanger 中的类型参数" rel="nofollow">V</a></td> 
> > > <td style="width:399.95pt;padding:2.25pt 2.25pt 2.25pt 2.25pt;border-left:none;border-right:1pt outset;border-top:1pt outset;border-bottom:1pt outset;background:rgb(255,255,255);"><a rel="nofollow">exchange</a>(<a title="Exchanger 中的类型参数" rel="nofollow">V</a>&nbsp;x) &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;等待另一个线程到达此交换点（除非当前线程被<a rel="nofollow">中断</a>），然后将给定的对象传送给该线程，并接收该线程的对象。</td> 
> > > </tr> 
> > > <tr> 
> > > <td style="width:16.05pt;padding:2.25pt;border-left:1pt outset;border-right:1pt outset;border-top:none;border-bottom:1pt outset;">&nbsp;<a title="Exchanger 中的类型参数" rel="nofollow">V</a></td> 
> > > <td style="width:399.95pt;padding:2.25pt;border-left:none;border-right:1pt outset;border-top:none;border-bottom:1pt outset;"><a rel="nofollow">exchange</a>(<a title="Exchanger 中的类型参数" rel="nofollow">V</a>&nbsp;x, long&nbsp;timeout, <a title="java.util.concurrent 中的枚举" rel="nofollow">TimeUnit</a>&nbsp;unit) &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;等待另一个线程到达此交换点（除非当前线程被<a rel="nofollow">中断</a>，或者超出了指定的等待时间），然后将给定的对象传送给该线程，同时接收该线程的对象。</td> 
> > > </tr> 
> > > </tbody> 
> > > </table>

**        3、举例**

# **    毒品交易  双方并不是同时到达，有先有后，只有都到达了，瞬间交换数据，各自飞** #

**代码演示：**

> >     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 ="abc";
> >     					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) {
> >     					e.printStackTrace();
> >     				}
> >     			}
> >     		});
> >     		//毒人：
> >     		service.execute(new Runnable()
> >     		{	
> >     			//吸毒人做的事
> >     			public void run()
> >     			{
> >     				try {
> >     					String data1 ="123";
> >     					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) {
> >     					e.printStackTrace();
> >     				}
> >     			}
> >     		});
> >     	}
> >     }

> **运行结果为：**

> > > **线程 pool-1-thread-1 正在把数据 abc 换出去**
> > 
> > **        线程 pool-1-thread-2 正在把数据 123 换出去**
> > 
> > **        线程 pool-1-thread-1换回的数据为 123**
> > 
> > **        线程 pool-1-thread-2换回的数据为 abc**
> > 
> >   
> >

>   
>