线程学习笔记-Exchanger

     Exchanger（交换者）是一个用于线程间协作的工具类。Exchanger用于进行线程间的数据交换。它提供一个同步点，在这个同步点两个线程(成对出现)可以交换彼此的数据。这两个线程通过exchange方法交换数据， 如果第一个线程先执行exchange方法，它会一直等待第二个线程也执行exchange，当两个线程都到达同步点时，这两个线程就可以交换数据，将本线程生产出来的数据传递给对方。因此使用Exchanger的重点是成对的线程使用exchange()方法，当有一对线程达到了同步点，就会进行交换数据。因此该工具类的线程对象是成对的。

   Exchanger类提供了两个方法，String exchange(V x):用于交换，启动交换并等待另一个线程调用exchange；String exchange(V x,long timeout,TimeUnit unit)：用于交换，启动交换并等待另一个线程调用exchange，并且设置最大等待时间，当等待时间超过timeout便停止等待。

注意点：
1.如果成对的线程没有到达交换点，线程将等待
2.线程是成对出现的

package com.picc.concerrent3.chapter5;

import java.util.concurrent.Exchanger;
import java.util.concurrent.TimeUnit;

public class ExchangerExample1 {
  public static void main(String[] args) {
    Exchanger<String> exchanger = new Exchanger<>();
    /**
     * 线程一已经到达了交换点，线程二到达之后会立即返回
     */
    new Thread(new Runnable() {
      @Override
      public void run() {
        System.out.println(Thread.currentThread().getName()+" start.");
        try {
          String value = exchanger.exchange("i am come from T-a");
          System.out.println(Thread.currentThread().getName()+" get value {" + value);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+" finish");
      }
    },"===A===").start();

    new Thread(new Runnable() {
      @Override
      public void run() {
        System.out.println(Thread.currentThread().getName()+" start.");
        try {
          TimeUnit.SECONDS.sleep(20);
          String value = exchanger.exchange("i am come from T-B");
          System.out.println(Thread.currentThread().getName()+" get value {" + value);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+" finish");
      }
    },"===B===").start();
  }
}

两个线程不断交换数据

package com.picc.concerrent3.chapter5;

import java.util.concurrent.Exchanger;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;

public class ExchangerExample3 {
  public static void main(String[] args) {
    Exchanger<Integer> exchanger = new Exchanger<>();

    new Thread(){
      @Override
      public void run() {
        AtomicReference<Integer> value = new AtomicReference<>(1);
        try {
          while(true){
            value.set(exchanger.exchange(value.get()));
            System.out.println("thread a has value "+ value.get());
            TimeUnit.SECONDS.sleep(3);
          }
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
    }.start();

    new Thread(){
      @Override
      public void run() {
        AtomicReference<Integer> value = new AtomicReference<>(2);
        try {
          while(true){
            value.set(exchanger.exchange(value.get()));
            System.out.println("thread b has value "+ value.get());
            TimeUnit.SECONDS.sleep(3);
          }
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
    }.start();
  }
}