Exchanger

package com.thread.test;

import java.util.concurrent.Exchanger;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExchangerTest {

	public static void main(String[] args) {
		Exchanger<String> exchanger = new Exchanger<String>();
		// 指定两个线程，用于线程之间交换数据，exchanger做线程之间的数据交换时，只能每两个线程之间“配对”，
		// 如果奇数个线程使用同一个exchanger对象做数据交换，那么会剩余一个线程得不到配对而一直等待，
		// 当然，可以使用String exchange(V x,long timeout,TimeUnit unit)设置最大等待时间使程序抛出异常终止。
		ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(2);

		newFixedThreadPool.execute(new Runnable() {
			@Override
			public void run() {
				try {
					String A = "数据A";
					String exchangeA = exchanger.exchange(A);
					System.err.println("exchangeA：" + exchangeA);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		});

		newFixedThreadPool.execute(new Runnable() {
			@Override
			public void run() {
				try {
					String B = "数据A";
					String exchangerB = exchanger.exchange(B);
					System.err.println("exchangerB：" + exchangerB);
					System.err.println(B.equals(exchangerB));
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		});

		/*newFixedThreadPool.execute(new Runnable() {

			@Override
			public void run() {
				try {
					String C = "数据C";
					String A = exchanger.exchange(C);
					System.err.println(A.equals(C));
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		});

		newFixedThreadPool.execute(new Runnable() {

			@Override
			public void run() {
				try {
					String D = "数据C";
					String A = exchanger.exchange(D);
					System.err.println(A.equals(D));
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		});*/

		newFixedThreadPool.shutdown();
	}
}