Java：Echanger类实现高昂创建对象交换点

Exchanger

1）java.util.concurrent.Exchanger 是 两个任务之间交换对象的同步点，他们各自拥有一个配对对象，每个线程上的某个方法城呈现给Exchanger.exchange方法，并且在返回时接收器对方拥有的配对对象；

2）Exchanger的典型应用场景：一个任务在创建对象时，这些对象创建的代价很高昂，而另一个任务消费该对象，通过这种方式可以使更多的高昂创建对象，在创建时就被消费，减少高昂对象在内存中的停留时间；

//生产线程，不断将交换得来的空holder列表填充为满holder，并重新交换出去
class ExchangerProducer<T> implements Runnable{
     private Class<T> objectClass;  //用于产生新的T对象实例
     private Exchanger<List<T>> exchanger;  //记录T对象列表的交换同步点；
     private List<T> holder = new ArrayList<T>();     //记录T对象的列表
     private int size ;   //holder列表的长度
     public ExchangerProducer<T>(Class<T> objectClass,Exchanger<List<T>> exchanger,int size){
          this.objectClass = objectClass;
          this.exchanger = exchanger;
          this.size = size;
     }
     public void run(){
          try{
               while(!Thread.interrupted()){
                    for(int i=0;i<size;i++)
                        holder.add(objectClass.newInstance());  //创建T对象，并填满holder列表
                    exchanger.exchange(holder);  //将满的holder交换为空的holder，重新不断地填充holder
               }
          }catch(InterruptedException ex){
          }
     }
}
//消费线程，不断消费交换得满holder，产生空的holder列表，并将其交换出去
class ExchangerConsumer<T> impelements Runnable{
     private Exchanger<List<T>> exchanger;
     priavte List<T> holder = new ArrayList<T>();
     priavte volatile T value;
     public ExchangerConsumer(ExchangerConsumer<List<T>> exchanger){
          this.exchanger = exchanger;
     }
     public void run(){
          try{
               while(!Thread.interruped()){
                    holder = exchanger.exchange(holder);   //通过交换获取holder列表
                    for(T x : holder){
                         value = x;        //获取列表中的T元素并使用它
                         <using value to do something >
                         holder.remove(x);   //删除列表中的T元素，逐步恢复holder为空列表
                    }
               }
          }catch(InterruptedException ex){
          }
     }
}
//Test
class Driver{
     void main(){
          Exchanger<List<HightCostObj>> exchanger = new Exchanger<List<HightCostObj>>();
          ExecutorServcie exec = Executors.newCachedThreadPool();
          exec.execute(new ExchangerProducer<HightCostObj>(HightCostObj.class,exchanger,N));
          exec.execute(new ExchangerConsumer<HightCostObj>(exchanger));

          TimeUnit.SECONDS.sleep(120);
          execute.shutdownNow()
     }
}