Java并发编程 - 两个线程进行数据交换 - 《Java 笔记》

Exchanger 简介
Exchanger 实战

Java

Exchanger 简介

Exchanger 就是线程之间的数据交换器，只能用于两个线程之间的数据交换。
Exchanger 提供了两个公开方法：

1、只带泛型 V（交换的数据对象）的方法，线程一直阻塞，直到其他任意线程和它交换数据，或者被线程中断。
2、另外一个带时间的方法，如果超过设置时间还没有线程和它交换数据，就会抛出 TimeoutException 异常；

Exchanger 实战

简单数据交换

来一个两个线程正常数据交换的简单示例：

private static void test1() {
    Exchanger exchanger = new Exchanger();
    new Thread(() -> {
        try {
            Object data = "-公众号Java技术栈AAA";
            System.out.println(Thread.currentThread().getName() + data);
            // 开始交换数据
            data = exchanger.exchange(data);
            System.out.println(Thread.currentThread().getName() + data);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }).start();
    new Thread(() -> {
        try {
            Object data = "-公众号Java技术栈BBB";
            System.out.println(Thread.currentThread().getName() + data);
            // 开始交换数据
            data = exchanger.exchange(data);
            System.out.println(Thread.currentThread().getName() + data);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }).start();
}

这段代码的逻辑：
1、创建并启动两个线程；
2、进行数据交换前先打印出自己线程的数据；
3、进行数据交换；
4、打印数据交换之后的数据；
输出结果：

从结果可以看出，线程 0、1 分别先打印出 A、B，数据交换之后，打印出了 B、A，数据交换正常！

超时数据交换

上面演示了两个线程的正常交换，下面再来一个带超时的示例：

private static void test2() {
    Exchanger exchanger = new Exchanger();
    new Thread(() -> {
        try {
            Object data = "-AAA";
            System.out.println(Thread.currentThread().getName() + data);
            // 开始交换数据
            data = exchanger.exchange(data, 3000L, TimeUnit.MILLISECONDS);
            System.out.println(Thread.currentThread().getName() + data);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }).start();
}

现在只启动了一个线程，并且设置了超时时间 3 秒。
首先线程输出了自己的数据，然后 3 秒后，并没有其他线程和它交换数据，所以抛出了超时异常，最后线程结束运行。

中断数据交换

线程开始交换数据后，会一直阻塞直到其他任意线程和它交换数据，或者被中断、超时，上面演示了超时，下面这个示例演示一下中断。

private static void test3() {
    Exchanger exchanger = new Exchanger();
    new Thread(() -> {
        try {
            Object data = "-AAA";
            System.out.println(Thread.currentThread().getName() + data);
            // 开始交换数据
            data = exchanger.exchange(data);
            System.out.println(Thread.currentThread().getName() + data);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }).start();
}

默认情况下不带超时设置会一直阻塞运行中……
现在再加入一段中断的逻辑：

private static void test3() throws InterruptedException {
    Exchanger exchanger = new Exchanger();
    Thread thread = new Thread(() -> {
        try {
            Object data = "-AAA";
            System.out.println(Thread.currentThread().getName() + data);
            // 开始交换数据
            data = exchanger.exchange(data);
            System.out.println(Thread.currentThread().getName() + data);
        } catch (Exception e) {
            e.printStackTrace();
        }
    });
    thread.start();
    // 线程中断
    Thread.sleep(3000L);
    thread.interrupt();
}

主线程休眠 3 秒后，中断该线程。
输出结果：

输出结果 3 秒后，线程被中断了，抛出了中断异常，线程也停止阻塞，最后线程结束运行。

两两数据交换

另外需要知道是，Exchanger 只能用于两个线程之间的数据交换，一个线程开启数据交换之后，会阻塞直到其他任意线程同样开启数据交换达到交换点。
最后来个示例，开启 10 个线程，看它们是怎么两两交换的：

private static void test4() {
    Exchanger exchanger = new Exchanger();
    for (int i = 1; i <= 10; i++) {
        Integer data = i;
        new Thread(() -> {
            try {
                Object exchange = exchanger.exchange(data);
                System.out.println(Thread.currentThread().getName() + "-" + exchange);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "Java" + i).start();
    }
}

输出结果：

可以看到，10 个线程，都两两交换彼此的数据了。