原创转载请注明出处：http://agilestyle.iteye.com/blog/2343280

exchange()阻塞

Exchanger中的exchange()方法具有阻塞的特点，也就是此方法被调用后等待其他线程来取数据，如果没有其他线程来取数据，则一直阻塞等待。

ThreadA.java

package org.fool.java.concurrent.exchange;

import java.util.concurrent.Exchanger;

public class ThreadA implements Runnable {

    private Exchanger<String> exchanger;

    public ThreadA(Exchanger<String> exchanger) {
        this.exchanger = exchanger;
    }

    @Override
    public void run() {
        try {
            System.out.println(exchanger.exchange("data from Thread A"));
            System.out.println("Thread A end...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

ExchangerTest.java

package org.fool.java.concurrent.exchange;

import java.util.concurrent.Exchanger;

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

        Thread thread = new Thread(new ThreadA(exchanger));

        thread.start();

        System.out.println("main end...");
    }
}

Run 

Note:

可以看到Console状态一直处于阻塞等待状态 

exchange()传递数据

再创建一个ThreadB.java

package org.fool.java.concurrent.exchange;

import java.util.concurrent.Exchanger;

public class ThreadB implements Runnable {

    private Exchanger<String> exchanger;

    public ThreadB(Exchanger<String> exchanger) {
        this.exchanger = exchanger;
    }

    @Override
    public void run() {
        try {
            System.out.println(exchanger.exchange("data from Thread B"));
            System.out.println("Thread B end...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

修改ExchangerTest.java

package org.fool.java.concurrent.exchange;

import java.util.concurrent.Exchanger;

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

        Thread threadA = new Thread(new ThreadA(exchanger));

        threadA.start();

        Thread threadB = new Thread(new ThreadB(exchanger));

        threadB.start();

        System.out.println("main end...");
    }
}

Run

exchange(V x, long timeout, TimeUnit unit)超时

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

ThreadC.java

package org.fool.java.concurrent.exchange;

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

public class ThreadC implements Runnable {

    private Exchanger<String> exchanger;

    public ThreadC(Exchanger<String> exchanger) {
        this.exchanger = exchanger;
    }

    @Override
    public void run() {
        try {
            System.out.println(exchanger.exchange("data from Thread C", 5, TimeUnit.SECONDS));
            System.out.println("Thread C end...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
    }
}

ExchangerTest2.java

package org.fool.java.concurrent.exchange;

import java.util.concurrent.Exchanger;

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

        Thread threadC = new Thread(new ThreadC(exchanger));

        threadC.start();

        System.out.println("main end...");
    }
}

Run