（12）java5的CountDownLatch、Exchanger同步工具

【1】CountDownLatch

java.util.concurrent 

类 CountDownLatch
java.lang.Object
  java.util.concurrent.CountDownLatch

public class CountDownLatchextends Object一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。 


用给定的计数 初始化 CountDownLatch。由于调用了 countDown() 方法，所以在当前计数到达零之前，await 方法会一直受阻塞。
之后，会释放所有等待的线程，await 的所有后续调用都将立即返回。
这种现象只出现一次——计数无法被重置。如果需要重置计数，请考虑使用 CyclicBarrier。 


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


CountDownLatch 的一个有用特性是，

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

示例用法： 下面给出了两个类，其中一组 worker 线程使用了两个倒计数锁存器： 


第一个类是一个启动信号，

在 driver 为继续执行 worker 做好准备之前，它会阻止所有的 worker 继续执行。 
第二个类是一个完成信号，它允许 driver 在完成所有 worker 之前一直等待。 

[java] view plaincopyprint?

1. class Driver { // ...  
2.        void main() throws InterruptedException {  
3.           CountDownLatch     startSignal = new CountDownLatch(1);  
4.           CountDownLatch    doneSignal = new CountDownLatch(N);  
5.   
6.      for (int i = 0; i < N; ++i) // create and start threads  
7.            new Thread(new Worker(startSignal, doneSignal)).start();  
8.   
9.            doSomethingElse();            // don't let run yet  
10.            startSignal.countDown();      // let all threads proceed  
11.            doSomethingElse();  
12.            doneSignal.await();           // wait for all to finish  
13.        }  
14.  }  
15.   
16.  class Worker implements Runnable {  
17.    private final CountDownLatch startSignal;  
18.    private final CountDownLatch doneSignal;  
19.    Worker(CountDownLatch startSignal, CountDownLatch doneSignal) {  
20.       this.startSignal = startSignal;  
21.       this.doneSignal = doneSignal;  
22.    }  
23.    public void run() {  
24.       try {  
25.         startSignal.await();  
26.         doWork();  
27.         doneSignal.countDown();  
28. } catch (InterruptedException ex) {} // return;  
29.    }  
30.   
31.    void doWork() { ... }  
32.  }  

 另一种典型用法是，将一个问题分成 N 个部分，用执行每个部分并让锁存器倒计数的 Runnable 来描述每个部分，然后将所有 Runnable 加入到 Executor 队列。当所有的子部分完成后，协调线程就能够通过 await。
 （当线程必须用这种方法反复倒计数时，可改为使用 CyclicBarrier。） 

[java] view plaincopyprint?

1. class Driver2 { // ...  
2.        void main() throws InterruptedException {  
3.          CountDownLatch doneSignal = new CountDownLatch(N);  
4.          Executor e = ...  
5.   
6.        for (int i = 0; i < N; ++i) // create and start threads  
7.              e.execute(new WorkerRunnable(doneSignal, i));  
8.   
9.             doneSignal.await();           // wait for all to finish  
10.       }  
11.  }  
12.   
13.  class WorkerRunnable implements Runnable {  
14.      private final CountDownLatch doneSignal;  
15.       private final int i;  
16.       WorkerRunnable(CountDownLatch doneSignal, int i) {  
17.              this.doneSignal = doneSignal;  
18.             this.i = i;  
19.    }  
20.    public void run() {  
21.       try {  
22.        doWork(i);  
23.        doneSignal.countDown();  
24.         } catch (InterruptedException ex) {} // return;  
25.    }  
26.   
27.       void doWork() { ... }  
28.  }  

内存一致性效果：线程中调用 countDown() 之前的操作 happen-before 紧跟在从另一个线程中对应 await() 成功返回的操作。


await
public void await()
           throws InterruptedException使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断。 
如果当前计数为零，则此方法立即返回。 


如果当前计数大于零，则出于线程调度目的，将禁用当前线程，且在发生以下两种情况之一前，该线程将一直处于休眠状态： 


由于调用 countDown() 方法，计数到达零；或者 
其他某个线程中断当前线程。 
如果当前线程： 

在进入此方法时已经设置了该线程的中断状态；或者 
在等待时被中断， 
则抛出 InterruptedException，并且清除当前线程的已中断状态。 


抛出： 
InterruptedException - 如果当前线程在等待时被中断。

应用实例：

[java] view plaincopyprint?

1. package com.itm.thread;  
2.   
3. /* 
4.  *  
5.  *  CountDownLatch可以看做是一个计数器，调用CountDown方法可以使计数-1； 
6.         当计数为0时，所有等待的线程都会开始运行。 
7.         这个方法可以实现让多个线程等待一个线程，也可以让一个线程等待多个线程。 
8.      
9.     */  
10. import java.util.Random;  
11. import java.util.concurrent.CountDownLatch;  
12. import java.util.concurrent.ExecutorService;  
13. import java.util.concurrent.Executors;  
14.   
15. public class CountDownLatchTest {  
16.     public static void main(String[] args) {  
17.         final CountDownLatch count1 = new CountDownLatch(1); // 总计数为1  
18.         final CountDownLatch count3 = new CountDownLatch(3); // 总计数为3  
19.         ExecutorService es = Executors.newCachedThreadPool();  
20.         for (int i = 0; i < 3; i++) {  
21.             es.execute(new Runnable() {  
22.                 @Override  
23.                 public void run() {  
24.                     try {  
25.                         System.out.println("线程"  
26.                                 + Thread.currentThread().getName() + "正在等待命令");  
27.                         count1.await(); // 当count1的计数为0时，线程才会向下运行  
28.                         System.out.println("线程"  
29.                                 + Thread.currentThread().getName()  
30.                                 + "已接到命令，开始执行");  
31.                         Thread.sleep(new Random().nextInt(5000));  
32.                         System.out.println("线程"  
33.                                 + Thread.currentThread().getName()  
34.                                 + "已完成命令，发出回应");  
35.                         count3.countDown(); // 每一个线程运行到这里就对count3的计数-1  
36.                     } catch (InterruptedException e) {  
37.                         e.printStackTrace();  
38.                     }  
39.                 }  
40.             });  
41.         }  
42. // main方法里面的代码 属于主线程。。。  
43.         try {  
44.             Thread.sleep(2000);  
45.               
46.             System.out.println("线程" + Thread.currentThread().getName()  
47.                     + "正准备发布命令");  
48.               
49.             count1.countDown(); // count1的计数-1  
50.             System.out.println("线程" + Thread.currentThread().getName()  
51.                     + "已发布命令，等待回应");  
52.               
53.               
54.             count3.await(); // 等待直到count3的计数为0  
55.             System.out.println("线程" + Thread.currentThread().getName()  
56.                     + "已收到全部回应");  
57.         } catch (InterruptedException e) {  
58.             e.printStackTrace();  
59.         }  
60.         es.shutdown();  
61.     }  
62. }  

运行结果：

线程pool-1-thread-1正在等待命令
线程pool-1-thread-3正在等待命令
线程pool-1-thread-2正在等待命令
线程main正准备发布命令
线程main已发布命令，等待回应
线程pool-1-thread-3已接到命令，开始执行
线程pool-1-thread-2已接到命令，开始执行
线程pool-1-thread-1已接到命令，开始执行
线程pool-1-thread-3已完成命令，发出回应
线程pool-1-thread-2已完成命令，发出回应
线程pool-1-thread-1已完成命令，发出回应
线程main已收到全部回应

【2】Exchanger

java.util.concurrent 
类 Exchanger<V>
java.lang.Object
  java.util.concurrent.Exchanger<V>
类型参数：
V - 可以交换的对象类型




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


用法示例：以下是重点介绍的一个类，该类使用 Exchanger 在线程间交换缓冲区，
因此，在需要时，填充缓冲区的线程获取一个新腾空的缓冲区，并将填满的缓冲区传递给腾空缓冲区的线程。 

[java] view plaincopyprint?

1. class FillAndEmpty {  
2.    Exchanger<DataBuffer> exchanger = new Exchanger<DataBuffer>();  
3.    DataBuffer initialEmptyBuffer = ... a made-up type  
4.    DataBuffer initialFullBuffer = ...  
5.   
6.    class FillingLoop implements Runnable {  
7.      public void run() {  
8.        DataBuffer currentBuffer = initialEmptyBuffer;  
9.        try {  
10.         while (currentBuffer != null) {  
11.              addToBuffer(currentBuffer);  
12.              if (currentBuffer.isFull())  
13.                currentBuffer = exchanger.exchange(currentBuffer);  
14.         }  
15.        } catch (InterruptedException ex) { ... handle ... }  
16.      }  
17.    }  
18.   
19.    class EmptyingLoop implements Runnable {  
20.      public void run() {  
21.         DataBuffer currentBuffer = initialFullBuffer;  
22.        try {  
23.          while (currentBuffer != null) {  
24.           takeFromBuffer(currentBuffer);  
25.           if (currentBuffer.isEmpty())  
26.                 currentBuffer = exchanger.exchange(currentBuffer);  
27.       }  
28.        } catch (InterruptedException ex) { ... handle ...}  
29.      }  
30.    }  
31.   
32.    void start() {  
33.      new Thread(new FillingLoop()).start();  
34.     new Thread(new EmptyingLoop()).start();  
35.    }  
36.   }  

内存一致性效果：对于通过 Exchanger 成功交换对象的每对线程，每个线程中在 exchange() 之前的操作 happen-before 从另一线程中相应的 exchange() 返回的后续操作。 






exchange

public V exchange(V x)
           throws InterruptedException等待另一个线程到达此交换点（除非当前线程被中断），然后将给定的对象传送给该线程，并接收该线程的对象。 
如果另一个线程已经在交换点等待，则出于线程调度目的，继续执行此线程，并接收当前线程传入的对象。


当前线程立即返回，接收其他线程传递的交换对象。 


如果还没有其他线程在交换点等待，则出于调度目的，禁用当前线程，且在发生以下两种情况之一前，该线程将一直处于休眠状态： 


其他某个线程进入交换点；或者 
其他某个线程中断当前线程。 
如果当前线程： 


在进入此方法时已经设置了该线程的中断状态；或者 
在等待交换时被中断， 
则抛出 InterruptedException，并且清除当前线程的已中断状态。 


参数：
x - 要交换的对象 
返回：
另一个线程提供的对象 
抛出： 
InterruptedException - 如果当前线程在等待时被中断.

应用实例：

[java] view plaincopyprint?

1. package com.itm.thread;  
2.   
3. import java.util.Random;  
4. import java.util.concurrent.Exchanger;  
5. import java.util.concurrent.ExecutorService;  
6. import java.util.concurrent.Executors;  
7.   
8. public class ExchangerTest {  
9.     public static void main(String[] args) {  
10.         final Exchanger<String> changer = new Exchanger<String>();  
11.         ExecutorService es = Executors.newCachedThreadPool();  
12.         es.execute(new Runnable() {  
13.             @Override  
14.             public void run() {  
15.                 String data1 = "aaa"; // data1表示这个线程准备拿出进行交换的数据  
16.                 try {  
17.                     System.out.println("线程" + Thread.currentThread().getName()  
18.                             + "要交换的数据为" + data1);  
19.                     Thread.sleep(new Random().nextInt(5000));  
20.                     System.out.println("线程" + Thread.currentThread().getName()  
21.                             + "已准备好交换");  
22.                       
23.                     String data2 = (String) changer.exchange(data1); // 线程将data1交给别的线程，接受别的线程传来的数据放入data2中  
24.                       
25.                     System.out.println("线程" + Thread.currentThread().getName()  
26.                             + "交换成功,交换到的数据为" + data2);  
27.                 } catch (InterruptedException e) {  
28.                     e.printStackTrace();  
29.                 }  
30.   
31.             }  
32.         });  
33.         es.execute(new Runnable() {  
34.             @Override  
35.             public void run() {  
36.                 String data1 = "bbb"; // 要交换的数据的名字可以随意起，与交换线程的数据名称没有关系  
37.                 try {  
38.                     System.out.println("线程" + Thread.currentThread().getName()  
39.                             + "要交换的数据为" + data1);  
40.                     Thread.sleep(new Random().nextInt(5000));  
41.                     System.out.println("线程" + Thread.currentThread().getName()  
42.                             + "已准备好交换");  
43.                       
44.                     String data2 = (String) changer.exchange(data1);  
45.                       
46.                     System.out.println("线程" + Thread.currentThread().getName()  
47.                             + "交换成功,交换到的数据为" + data2);  
48.                 } catch (InterruptedException e) {  
49.                     e.printStackTrace();  
50.                 }  
51.             }  
52.         });  
53.         es.shutdown();  
54.     }  
55. }  

运行结果：

线程pool-1-thread-1要交换的数据为aaa
线程pool-1-thread-2要交换的数据为bbb
线程pool-1-thread-1已准备好交换
线程pool-1-thread-2已准备好交换
线程pool-1-thread-2交换成功,交换到的数据为aaa
线程pool-1-thread-1交换成功,交换到的数据为bbb