[笔记][Java7并发编程实战手冊]系列文件夹

简单介绍

　　Exchanger 是一个同步辅助类。用于两个并发线程之间在一个同步点进行数据交换。
　　同意两个线程在某一个点进行数据交换。

---

本章exchanger 使用心得总结

1. 两个线程必须使用同一个Exchanger对象，且仅仅能是两个线程间的数据交换


2. exchanger.exchange(ｖ)的时候，当前线程会被堵塞，直到还有一个线程运行该方法，同一时候完成数据的交换


3. 相似这样的数据交换的，生产者线程一定要先生产数据。再交换数据，消费者线程一定要先交换数据，再消费数据，否则会出现少消费数据的现象

---

演示样例

场景描写叙述：一对一的 生产者和消费者。生产者每次生产5个商品，然后消费者把空的商品容器和生产者交换。

/**
* Created by zhuqiang on 2015/8/23 0023.
*/
public class Client {
public static void main(String[] args) {
Exchanger> exchanger = new Exchanger>();
new Thread(new Producer(exchanger)).start();
new Thread(new Consumer(exchanger)).start();
}
}
// 生产者
class Producer implements Runnable {
private ArrayList goods = new ArrayList(); //商品容器
private Exchanger> exchanger = new Exchanger>();
public Producer(Exchanger> exchanger) {
this.exchanger = exchanger;
}
@Override
public void run() {
for (int i = 0; i <3; i++) { //生产3次
System.out.println("------------------------生产者生产第 " + i + "次");
for (int j = 0; j <3; j++) { //每次生产3个商品
String e = (long) (Math.random() * 1000) + "";
goods.add(e);
System.out.println("生产了商品：" + e);
}
try {
goods = exchanger.exchange(goods); //交换数据
System.out.println("生产者：数据交换完成：获得交换的商品容器大小：" + goods.size());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
//消费者
class Consumer implements Runnable {
private ArrayList goods = new ArrayList(); //商品容器
private Exchanger> exchanger = new Exchanger>();
public Consumer(Exchanger> exchanger) {
this.exchanger = exchanger;
}
@Override
public void run() {
for (int i = 0; i <3; i++) { //消费3次
try {
goods = exchanger.exchange(goods); //交换数据
System.out.println("消费者：数据交换完成：获得交换的商品容器大小：" + goods.size());
// 消费商品
Iterator it = goods.iterator();
if (goods.size() > 0) {
System.out.println("*********************消费者消费第 " + i + "次");
while (it.hasNext()) {
String next = it.next();
System.out.println("消费了商品：" + next);
it.remove(); //移除消费了的商品
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

某一次运行结果：

------------------------生产者生产第 0次
生产了商品：727
生产了商品：671
生产了商品：345
生产者：数据交换完成：获得交换的商品容器大小：0
------------------------生产者生产第 1次
生产了商品：67
生产了商品：466
生产了商品：207
消费者：数据交换完成：获得交换的商品容器大小：3
*********************消费者消费第 0次
消费了商品：727
消费了商品：671
消费了商品：345
消费者：数据交换完成：获得交换的商品容器大小：3
生产者：数据交换完成：获得交换的商品容器大小：0
------------------------生产者生产第 2次
*********************消费者消费第 1次
消费了商品：67
消费了商品：466
消费了商品：207
生产了商品：38
生产了商品：355
生产了商品：24
生产者：数据交换完成：获得交换的商品容器大小：0
消费者：数据交换完成：获得交换的商品容器大小：3
*********************消费者消费第 2次
消费了商品：38
消费了商品：355
消费了商品：24

结果说明
看上面的结果，能够发现两个线程是并行运行的，仅仅有在交换的时候，交换数据同步点。

是不是认为看着不明所以。这样看
————————生产者生产第 0次
生产了商品：727

第0次生产商品是 727。
***********消费者消费第 0次
消费了商品：727

第0次消费的也是727， 这就说明了。两个线程之间交换数据是我们想要的结果。

假如：我们把 以下的运行顺序调换下，让consumer在前。结果你发现还是先生产后消费。

这个是为什么呢？

new Thread(new Producer(exchanger)).start();
new Thread(new Consumer(exchanger)).start();

是由于：
1. 从java内存模型角度来说。上面两行代码没有数据依赖性（在实际运行的时候他们的顺序不一定是谁先谁后）
2. 原因就出如今exchanger.exchange(ｖ)方法。就算是消费者先运行，细致看代码。消费者会先运行exchanger.exchange(ｖ)方法。假设之前没有线程运行该方法，那么消费者则会休眠等待生产者运行该方法。