Java并发之Exchanger详解

ava 并发 API 提供了一种允许2个并发任务间相互交换数据的同步应用。更具体的说，Exchanger类允许在2个线程间定义同步点，当2个线程到达这个点，他们相互交换数据类型，使用第一个线程的数据类型变成第二个的，然后第二个线程的数据类型变成第一个的。

示例1
一个人有零食，另一个人有钱，他们两个想等价交换，对好口号在某个地方相见，一个人先到了之后，必须等另一个人带着需要的东西来了之后，才能开始交换。

[java]  view plain  copy

1. public class ExchangerTest  
2. {  
3.     public static void main(String[] args)  
4.     {  
5.         ExecutorService service = Executors.newCachedThreadPool();  
6.         final Exchanger<String> exchanger = new Exchanger<String>();  
7.         service.execute(new Runnable()  
8.         {  
9.             public void run()  
10.             {  
11.                 try  
12.                 {  
13.                     String data1 = "零食";  
14.                     System.out.println("线程" + Thread.currentThread().getName() + "正在把数据" + data1 + "换出去");  
15.                     Thread.sleep((long) (Math.random() * 1000));  
16.                     String data2 = exchanger.exchange(data1);  
17.                     System.out.println("线程" + Thread.currentThread().getName() + "换回的数据为" + data2);  
18.                 }  
19.                 catch (Exception e)  
20.                 {  
21.                 }  
22.             }  
23.         });  
24.   
25.         service.execute(new Runnable()  
26.         {  
27.             public void run()  
28.             {  
29.                 try  
30.                 {  
31.                     String data1 = "钱";  
32.                     System.out.println("线程" + Thread.currentThread().getName() + "正在把数据" + data1 + "换出去");  
33.                     Thread.sleep((long) (Math.random() * 1000));  
34.                     String data2 = exchanger.exchange(data1);  
35.                     System.out.println("线程" + Thread.currentThread().getName() + "换回的数据为" + data2);  
36.                 }  
37.                 catch (Exception e)  
38.                 {  
39.                 }  
40.             }  
41.         });  
42.     }  
43. }  

线程pool-1-thread-1正在把数据零食换出去
线程pool-1-thread-2正在把数据钱换出去
线程pool-1-thread-2换回的数据为零食
线程pool-1-thread-1换回的数据为钱


示例2
这个类在遇到类似生产者和消费者问题时，是非常有用的。来一个非常经典的并发问题：你有相同的数据buffer，一个或多个数据生产者，和一个或多个数据消费者。只 是Exchange类只能同步2个线程 ，所以你只能在你的生产者和消费者问题中只有一个生产者和一个消费者时使用这个类。

[java]  view plain  copy

1. public class Producer implements Runnable  
2. {  
3.   
4.     // 要被相互交换的数据类型。  
5.     private List<String> buffer;  
6.   
7.     // 用来同步 producer和consumer  
8.     private final Exchanger<List<String>> exchanger;  
9.   
10.     public Producer(List<String> buffer, Exchanger<List<String>> exchanger)  
11.     {  
12.         this.buffer = buffer;  
13.         this.exchanger = exchanger;  
14.     }  
15.   
16.     public void run()  
17.     {  
18.         // 实现10次交换  
19.         for (int i = 0; i < 10; i++)  
20.         {  
21.             buffer.add("第" + i + "次生产者的数据" + i);  
22.             try  
23.             {  
24.                 // 调用exchange方法来与consumer交换数据  
25.                 System.out.println("第" + i + "次生产者在等待.....");  
26.                 buffer = exchanger.exchange(buffer);  
27.                 System.out.println("第" + i + "次生产者交换后的数据：" + buffer.get(i));  
28.             }  
29.             catch (InterruptedException e)  
30.             {  
31.                 e.printStackTrace();  
32.             }  
33.         }  
34.     }  
35. }  
36.   
37.   
38. public class Consumer implements Runnable  
39. {  
40.     // 用来相互交换  
41.     private List<String> buffer;  
42.   
43.     // 用来同步 producer和consumer  
44.     private final Exchanger<List<String>> exchanger;  
45.   
46.     public Consumer(List<String> buffer, Exchanger<List<String>> exchanger)  
47.     {  
48.         this.buffer = buffer;  
49.         this.exchanger = exchanger;  
50.     }  
51.   
52.     public void run()  
53.     {  
54.         // 实现10次交换  
55.         for (int i = 0; i < 10; i++)  
56.         {  
57.             buffer.add("第" + i + "次消费者的数据" + i);  
58.             try  
59.             {  
60.                 // 调用exchange方法来与consumer交换数据  
61.                 System.out.println("第" + i + "次消费者在等待.....");  
62.                 buffer = exchanger.exchange(buffer);  
63.                 System.out.println("第" + i + "次消费者交换后的数据：" + buffer.get(i));  
64.             }  
65.             catch (InterruptedException e)  
66.             {  
67.                 e.printStackTrace();  
68.             }  
69.         }  
70.     }  
71. }  
72.   
73. public class Core  
74. {  
75.     public static void main(String[] args)  
76.     {  
77.         // 创建2个buffers，分别给producer和consumer使用  
78.         List<String> buffer1 = new ArrayList<String>();  
79.         List<String> buffer2 = new ArrayList<String>();  
80.   
81.         // 创建Exchanger对象，用来同步producer和consumer  
82.         Exchanger<List<String>> exchanger = new Exchanger<List<String>>();  
83.   
84.         // 创建Producer对象和Consumer对象  
85.         Producer producer = new Producer(buffer1, exchanger);  
86.         Consumer consumer = new Consumer(buffer2, exchanger);  
87.   
88.         // 创建线程来执行producer和consumer并开始线程  
89.         Thread threadProducer = new Thread(producer);  
90.         Thread threadConsumer = new Thread(consumer);  
91.         threadProducer.start();  
92.         threadConsumer.start();  
93.     }  
94. }  

Exchanger 类有另外一个版本的exchange方法
exchange(V data, long time, TimeUnit unit)
V是声明参数种类，例子中是List
此线程会休眠直到另一个线程到达并中断它，或者特定的时间过去了
TimeUnit类有多种常量，DAYS、HOURS、MICROSECONDS、MILLISECONDS、MINUTES、NANOSECONDS和SECONDS