Exchanger的使用

类Exchanger的功能可以使2个线程之间传输数据，它比生产者/消费者模式使用的wait/notify要更加方便。所以本次将介绍此类在2个线程之间传递任意数据类型的数据，Exchanger类的使用与结构相当简单，主要的学习点就是exchange（）方法。

方法exchange（）阻塞的特性

类Exchanger中的exchange（）方法具有阻塞的特色，也就是次方法被调用后等待其他线程来取数据，如果没有其他线程取得数据，则一直阻塞。

创建测试用的项目Exchanger_1，创建类ThreadA.java代码如下：

package com.yc.exchanger;

import java.util.concurrent.Exchanger;

public class ThreadA extends Thread{
	Exchanger<String> exchanger = new Exchanger<String>();
	
	public ThreadA(Exchanger<String> exchanger){
		this.exchanger = exchanger;
	}
	@Override
	public void run() {
		super.run();
		try {
			System.out.println("在线程A中得到线程B的值=" + exchanger.exchange("中国人A"));
			System.out.println("A end!");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
}

运行时类ExchangerTest.java代码如下：

package com.yc.exchanger;

import java.util.concurrent.Exchanger;

public class ExchangerTest {
	public static void main(String[] args) {
		Exchanger<String> exchanger = new Exchanger<String>();
		ThreadA a = new ThreadA(exchanger);
		a.start();
		System.out.println("main end!");
	}
}

运行结果如下：

方法exchange（）传递数据

创建测试用的项目Exchanger_2，创建ThreadA.java类代码如下：

package com.yc.exchanger;

import java.util.concurrent.Exchanger;

public class ThreadA extends Thread{
	Exchanger<String> exchanger = new Exchanger<String>();
	
	public ThreadA(Exchanger<String> exchanger){
		this.exchanger = exchanger;
	}
	@Override
	public void run() {
		super.run();
		try {
			System.out.println("在线程A中得到线程B的值=" + exchanger.exchange("中国人A"));
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
}

创建类ThreadB.java代码如下：

package com.yc.exchanger;

import java.util.concurrent.Exchanger;

public class ThreadB extends Thread{
	Exchanger<String> exchanger = new Exchanger<String>();
	
	public ThreadB(Exchanger<String> exchanger){
		this.exchanger = exchanger;
	}
	@Override
	public void run() {
		super.run();
		try {
			System.out.println("在线程B中得到线程A的值=" + exchanger.exchange("中国人B"));
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
}

运行类ExchangerTest.java如下：

package com.yc.exchanger;

import java.util.concurrent.Exchanger;

public class ExchangerTest {
	public static void main(String[] args) {
		Exchanger<String> exchanger = new Exchanger<String>();
		ThreadA a = new ThreadA(exchanger);
		ThreadB b = new ThreadB(exchanger);
		a.start();
		b.start();
	}
}

运行结果为：

方法exchange（V  x, long  timeout,  TimeUnit  unit）与超时

当调用exchange（V  x, long  timeout,  TimeUnit  unit）方法后在指定的时间内没有其他线程获取数据，则出现超时异常。

创建测试用的项目Exchanger_3，创建类ThreadA.java代码如下：

package com.yc.exchanger;

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

public class ThreadA extends Thread{
	Exchanger<String> exchanger = new Exchanger<String>();
	
	public ThreadA(Exchanger<String> exchanger){
		this.exchanger = exchanger;
	}
	@Override
	public void run() {
		super.run();
		try {
			System.out.println("在线程A中得到线程B的值=" + 
					exchanger.exchange("中国人A", 5, TimeUnit.SECONDS));
			System.out.println("A end!");
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (TimeoutException e) {
			e.printStackTrace();
		}
	}
	
}

运行类ExchangerTest.java代码如下：

package com.yc.exchanger;

import java.util.concurrent.Exchanger;

public class ExchangerTest {
	public static void main(String[] args) {
		Exchanger<String> exchanger = new Exchanger<String>();
		ThreadA a = new ThreadA(exchanger);
		a.start();
		
		System.out.println("main end!");
	}
}

测试结果为：

下面看一下exchange（）方法的源码：

/**
     * Waits for another thread to arrive at this exchange point (unless
     * the current thread is {@linkplain Thread#interrupt interrupted}),
     * and then transfers the given object to it, receiving its object
     * in return.（在当前线程不被打断的情况下等待其他线程到达exchange点，然后转换其他线程带来的Object）
     *
     * <p>If another thread is already waiting at the exchange point then
     * it is resumed for thread scheduling purposes and receives the object
     * passed in by the current thread.  The current thread returns immediately,
     * receiving the object passed to the exchange by that other thread.
     *
     * <p>If no other thread is already waiting at the exchange then the
     * current thread is disabled for thread scheduling purposes and lies
     * dormant until one of two things happens:
     * <ul>
     * <li>Some other thread enters the exchange; or
     * <li>Some other thread {@linkplain Thread#interrupt interrupts}
     * the current thread.
     * </ul>
     * <p>If the current thread:
     * <ul>
     * <li>has its interrupted status set on entry to this method; or
     * <li>is {@linkplain Thread#interrupt interrupted} while waiting
     * for the exchange,
     * </ul>
     * then {@link InterruptedException} is thrown and the current thread's
     * interrupted status is cleared.
     *
     * @param x the object to exchange(参数x指的是要去交换的对象)
     * @return the object provided by the other thread（返回的是其他线程提供的对象）
     * @throws InterruptedException if the current thread was
     *         interrupted while waiting（当当前正在等待的线程被打断时抛出InterruptedException异常）
     */
    public V exchange(V x) throws InterruptedException {
        if (!Thread.interrupted()) { //如果当前线程未中断
            Object v = doExchange((x == null) ? NULL_ITEM : x, false, 0);
            if (v == NULL_ITEM)  
                return null;	//NULL_ITEM 和 CANCEL都是Exchanger类的两个私有的、静态的、不可变的对象，且都new了
            					//private static final Object CANCEL = new Object();
            					//private static final Object NULL_ITEM = new Object();
            if (v != CANCEL)
                return (V)v;
            Thread.interrupted(); // Clear interrupt status on IE throw
        }
        throw new InterruptedException();
    }

 private Object doExchange(Object item, boolean timed, long nanos) {
        Node me = new Node(item);                 // Create in case occupying(Node是Exchanger类的一个内部类有两个
        										  //变量  public final Object item; 和  public volatile Thread waiter;)
        int index = hashIndex();                  // Index of current slot
        int fails = 0;                            // Number of CAS failures

        for (;;) {
            Object y;                             // Contents of current slot
            Slot slot = arena[index];
            if (slot == null)                     // Lazily initialize slots
                createSlot(index);                // Continue loop to reread
            else if ((y = slot.get()) != null &&  // Try to fulfill
                     slot.compareAndSet(y, null)) {
                Node you = (Node)y;               // Transfer item
                if (you.compareAndSet(null, item)) {
                    LockSupport.unpark(you.waiter);
                    return you.item;
                }                                 // Else cancelled; continue
            }
            else if (y == null &&                 // Try to occupy
                     slot.compareAndSet(null, me)) {
                if (index == 0)                   // Blocking wait for slot 0
                    return timed ?
                        awaitNanos(me, slot, nanos) :
                        await(me, slot);
                Object v = spinWait(me, slot);    // Spin wait for non-0
                if (v != CANCEL)
                    return v;
                me = new Node(item);              // Throw away cancelled node
                int m = max.get();
                if (m > (index >>>= 1))           // Decrease index
                    max.compareAndSet(m, m - 1);  // Maybe shrink table
            }
            else if (++fails > 1) {               // Allow 2 fails on 1st slot
                int m = max.get();
                if (fails > 3 && m < FULL && max.compareAndSet(m, m + 1))
                    index = m + 1;                // Grow on 3rd failed slot
                else if (--index < 0)
                    index = m;                    // Circularly traverse
            }
        }
    }

有兴趣的同学完全可以去研究研究Exchanger这个类。