【Java并发编程】02.Exchanger的使用

Java并发编程是我刚刚开设的一个专栏，记录我学习Java并发编程的笔记、思考，希望大家共同进步。专栏地址：http://blog.csdn.net/column/details/14538.html，欢迎关注。

本专栏所有的代码我都会上传到GitHub。
GitHub地址是：https://github.com/mrbcy/JavaConcurrentLearn

本来过几天我才会有时间再看并发编程的，但是今天收到通知说专栏申请通过了，那没啥好说的，今天一定要更新一篇。

这次我们关注的类是Exchanger，它主要用于两个线程之间传递数据，比生产者/消费者模型中使用的wait/notify更加的方便。这篇博客会给出Exchanger类在两个线程之间传递任意类型数据的示例。

Exchanger类的结构和使用非常简单，主要就是学习exchange()方法的使用。

方法exchange()的阻塞特性

类Exchanger中的exchange()方法具有阻塞特性，调用该方法后会等待其他线程来取得数据，如果没有其他线程取得数据，会一直阻塞等待。

示例代码如下：

ThreadA.java

package tech.mrbcy.javaconcurrentlearn.e02_1;import java.util.concurrent.Exchanger;public class ThreadA extends Thread{    private Exchanger<String> exchanger;    public ThreadA(Exchanger<String> exchanger) {        super();        this.exchanger = exchanger;    }    @Override    public void run() {        super.run();        try {            System.out.println("在线程A中得到线程B中的值：" + exchanger.exchange("AAAAA"));        } catch (InterruptedException e) {            e.printStackTrace();        }    }}

Run.java

package tech.mrbcy.javaconcurrentlearn.e02_1;import java.util.concurrent.Exchanger;public class Run {    public static void main(String[] args) {        Exchanger<String> exchanger = new Exchanger<String>();        ThreadA a = new ThreadA(exchanger);        a.start();        System.out.println("main end!");    }}

运行后，ThreadA会阻塞，效果如图所示：

使用exchange()方法传递值

在上面的例子中再添加一个类，ThreadB

ThreadB.java

package tech.mrbcy.javaconcurrentlearn.e02_2;import java.util.concurrent.Exchanger;public class ThreadB extends Thread{    private Exchanger<String> exchanger;    public ThreadB(Exchanger<String> exchanger) {        super();        this.exchanger = exchanger;    }    @Override    public void run() {        super.run();        try {            System.out.println("在线程B中得到线程A中的值：" + exchanger.exchange("BBBBB"));        } catch (InterruptedException e) {            e.printStackTrace();        }    }}

然后略微修改一下Run

package tech.mrbcy.javaconcurrentlearn.e02_2;import java.util.concurrent.Exchanger;public class Run {    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();    }}

运行一下就可以看到ThreadA和ThreadB分别拿到了对方传过来的值。

运行结果：

在线程B中得到线程A中的值：AAAAA在线程A中得到线程B中的值：BBBBB

exchange()方法的超时

exchanger()方法的调用方也可以指定在多长时间内没有其他线程获取数据，则不再等待，抛出超时异常。

再把ThreadA修改一下，然后把Run再改回最开始的样子。

ThreadA.java

package tech.mrbcy.javaconcurrentlearn.e02_3;import java.util.concurrent.Exchanger;import java.util.concurrent.TimeUnit;import java.util.concurrent.TimeoutException;public class ThreadA extends Thread{    private Exchanger<String> exchanger;    public ThreadA(Exchanger<String> exchanger) {        super();        this.exchanger = exchanger;    }    @Override    public void run() {        super.run();        try {            System.out.println("在线程A中得到线程B中的值：" + exchanger.exchange("AAAAA", 5, TimeUnit.SECONDS));            System.out.println("A end!");        } catch (InterruptedException e) {            e.printStackTrace();        } catch (TimeoutException e) {            e.printStackTrace();        }    }}

Run.java

package tech.mrbcy.javaconcurrentlearn.e02_3;import java.util.concurrent.Exchanger;public class Run {    public static void main(String[] args) {        Exchanger<String> exchanger = new Exchanger<String>();        ThreadA a = new ThreadA(exchanger);        a.start();        System.out.println("main end!");    }}

运行结果如下：

main end!java.util.concurrent.TimeoutException    at java.util.concurrent.Exchanger.exchange(Exchanger.java:683)    at tech.mrbcy.javaconcurrentlearn.e02_3.ThreadA.run(ThreadA.java:20)

总结

使用Exchanger类可以方便的在线程间传递数据，而且数据的类型没有任何限制。