Thinking in Java学习笔记，使用Exchanger交换资源

生产者生产出的产品放入生产者队列，消费者等待消费者队列和生产者队列完成交换

package com.test.concurrent;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.Exchanger;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class ExchangerDemo {
static int size=10;
public static void main(String[] args) throws InterruptedException {
// TODO Auto-generated method stub
List<Fat> produceList=new CopyOnWriteArrayList<Fat>();
List<Fat> consumeList=new CopyOnWriteArrayList<Fat>();
Exchanger<List<Fat>> xc=new Exchanger<List<Fat>>();
ExecutorService exec=Executors.newCachedThreadPool();
exec.execute(new ExchangerProducer(xc,BasicGenerator.create(Fat.class),produceList));
exec.execute(new ExchangerConsumer(consumeList,xc));

TimeUnit.SECONDS.sleep(5);
exec.shutdownNow();
}

}
class ExchangerProducer<T> implements Runnable{
private List<T> holder;
private Exchanger<List<T>> exchanger;
private Generator<T> generator;
public ExchangerProducer(Exchanger<List<T>> exchanger,Generator<T> generator,List<T> holder){
this.exchanger=exchanger;
this.holder=holder;
this.generator=generator;
}
@Override
public void run(){
try {
while(!Thread.interrupted()){
for(int i=0;i<ExchangerDemo.size;i++){
holder.add(generator.next());
}
holder=exchanger.exchange(holder);
}
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

}
class ExchangerConsumer<T> implements Runnable{
private Exchanger<List<T>> exchanger;
private List<T> holder;
private volatile T value;
ExchangerConsumer(List<T> holder, Exchanger<List<T>> exchanger){
this.holder=holder;
this.exchanger=exchanger;
}
@Override
public void run(){
try{
while(!Thread.interrupted()){
holder=exchanger.exchange(holder);
for(T t:holder){
value=t;
holder.remove(t);
}
}
}catch(InterruptedException e){
e.printStackTrace();
}
System.out.println("Consume Final value: "+value);
}
}
class Fat{
private volatile double d; //prevent optimization
private static int counter=0;
private final int id=counter++;
public Fat(){
for(int i=0;i<10000;i++){
d+=(Math.PI+Math.E);
}
}
public String toString(){
return "Fat id: "+id+"  D:"+d;
}
public void operation(){
System.out.println(this);
}
}
interface Generator<T>{
T next();
}
class BasicGenerator<T> implements Generator<T>{
private Class<T> type;
public BasicGenerator(Class<T> type){
this.type=type;
}
public T next(){
try {
return type.newInstance();
} catch (InstantiationException | IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
public static <T> Generator<T> create(Class<T> type){
return new BasicGenerator<T>(type);
}
}

输出：

java.lang.InterruptedException

at java.util.concurrent.Exchanger.exchange(Unknown Source)

at com.test.concurrent.ExchangerProducer.run(ExchangerDemo.java:43)

at java.util.concurrent.ThreadPoolExecutor.runWorker(Unknown Source)

at java.util.concurrent.ThreadPoolExecutor$Worker.run(Unknown Source)

at java.lang.Thread.run(Unknown Source)

java.lang.InterruptedException

at java.util.concurrent.Exchanger.exchange(Unknown Source)

at com.test.concurrent.ExchangerConsumer.run(ExchangerDemo.java:64)

at java.util.concurrent.ThreadPoolExecutor.runWorker(Unknown Source)

at java.util.concurrent.ThreadPoolExecutor$Worker.run(Unknown Source)

at java.lang.Thread.run(Unknown Source)

Consume Final value: Fat id: 319279 D:58598.74482048422