Exchanger学习

lig

　　import java.util.List;
　　import java.util.concurrent.*;

　　public>
　　static int>　　static int delay = 5; //秒
　　public static void main(String[] args) throws Exception {
　　ExecutorService exec = Executors.newCachedThreadPool();
　　// 这个特定的List变体允许列表在被遍历的时候调用remove()方法，而不会抛出ConcurrentModifiedException异常
　　List<Fat> producerList = new CopyOnWriteArrayList<>();
　　List<Fat> consumerList = new CopyOnWriteArrayList<>();
　　Exchanger<List<Fat>> exchanger = new Exchanger<>();
　　exec.execute(new ExchangerProducer(exchanger, producerList));
　　exec.execute(new ExchangerConsumer(exchanger, consumerList));
　　TimeUnit.SECONDS.sleep(delay);
　　exec.shutdownNow();
　　}
　　}
　　class ExchangerProducer implements Runnable {
　　private List<Fat> holder;
　　private Exchanger<List<Fat>> exchanger;
　　public ExchangerProducer(Exchanger<List<Fat>> exchanger, List<Fat> holder) {
　　this.exchanger = exchanger;
　　this.holder = holder;
　　}
　　@Override
　　public void run() {
　　try {
　　while(!Thread.interrupted()) {
　　//生产对象
　　for (int i = 0;i < ExchangerDemo.size; i++) {
　　holder.add(new Fat());
　　}
　　//生产完毕后 等待进行交换
　　holder = exchanger.exchange(holder);
　　}
　　} catch (InterruptedException e) {
　　}
　　System.out.println(&quot;Producer stopped.&quot;);
　　}
　　}
　　class ExchangerConsumer implements Runnable {
　　private List<Fat> holder;
　　private Exchanger<List<Fat>> exchanger;
　　private volatile Fat value;
　　private static int num = 0;
　　public ExchangerConsumer(Exchanger<List<Fat>> exchanger, List<Fat> holder) {
　　this.exchanger = exchanger;
　　this.holder = holder;
　　}
　　@Override
　　public void run() {
　　try {
　　while(!Thread.interrupted()) {
　　//等待交换
　　holder = exchanger.exchange(holder);
　　//取到生产者生产的数据 开始模拟消费的场景
　　for (Fat x : holder) {
　　num ++;
　　value = x;
　　//消费 在循环内删除元素，这对于CopyOnWriteArrayList是没有问题的
　　holder.remove(x);
　　}
　　if (num % 10000 == 0) {
　　System.out.println(&quot;Exchanged count=&quot; + num);
　　}
　　}
　　} catch (InterruptedException e) {
　　}
　　System.out.println(&quot;Consumer stopped. Final value: &quot; + value);
　　}
　　}
　　class Fat {
　　private volatile double d;
　　private static int counter = 1;

　　private final int>　　public Fat() {
　　//执行一段耗时的操作
　　for (int i = 1; i<10000; i++) {
　　d += (Math.PI + Math.E) / (double)i;
　　}
　　}

　　public String toString() {return &quot;Fat>　　}