大家好，如果您在并发Java应用程序中工作，那么您可能听说过java.util.concurrent包的Exchanger类。 Java中的Exchanger是Java 1.5中与CountDownLatch ， CyclicBarrier和Semaphores一起引入的另一个并发或同步实用程序。 顾名思义， Exchanger允许两个线程在集合点或集合点见面并交换数据。 的 java.util.Exchanger是一个参数类，它定义并保存要交换的对象的类型。 它有一个重载的方法，称为 exchange() ，用于在线程之间交换对象。 这是一种阻塞方法，这意味着线程将调用 exchange()方法在交换点等待，直到另一个线程到达。 一旦另一个线程到达，两个线程都交换对象并从此方法返回。 交换方法的重载版本接受其他 TimeUnit对象，并等待直到超时。
顺便说一句，您还可以中断在交换点等待其他参与者的线程。 与CountDownLatch ， CyclicBarrier或Semaphore ， Exchanger实用程序只能同步两个线程，这使其非常适合解决经典的生产者－消费者问题 。
在本Java并发教程中，您将通过使用Exchanger实现生产者-消费者设计模式来学习如何在Java中使用Exchanger。 顺便说一句，我假设您熟悉Java编程语法和语义，如果您是Java的完整入门者，那么您可能会很难理解这个示例。
Exchanger类是一个易于理解和使用的简单同步实用程序。 在最后的两个并发教程中，我们使用了wait和notify解决了生产者使用者（请参阅此处 ），还使用BlockingQueue实现了生产者-消费者 ，现在该使用Exchanger来实现了。
在此Java并发性教程中， 我们将创建一个生产者和一个使用者线程 ，它们将使用Exchanger实用程序类交换缓冲区。
通常，这是Exchanger的工作方式：
1.首先，创建一个Exchange对象，例如Exchanger<Deque<Long>> stringExchanger = new Exchanger<>() ； 这定义了线程之间将交换什么类型的对象。 在这种情况下，两个线程将交换包含长值的Deque对象。
2.当线程A准备交换其缓冲区或对象时，它将调用 Exchanger.exchange()方法。 这是一种阻塞方法 ， 线程A将被阻塞，直到线程B到来并将其对象传输到线程A 为止，否则线程A被中断或超时。
3.线程B准备就绪时，它还会调用exchange()方法。 现在，线程A和B互相交换对象，并从交换方法返回。
4.交换完成后，线程A具有线程B的对象，反之亦然。
同样，我想强调Java并发技能的重要性，并敦促每个Java开发人员花一些时间来掌握Java并发类。
带有Exchanger并发的Java程序
import java.util.ArrayDeque; import java.util.Deque; import java.util.concurrent.Exchanger; /**
* Exchanger Example in Java. Exchanger allows two Threads to meet at exchange
* point and exchange data structure or objects. In this Java program, exchanger
* is used to exchange buffer between producer and consumer.
* @author Javin Paul
*/ public class JavaExchangerTutorail {
public static void main(String args[]) throws InterruptedException {
//Creating Exchanger to exchange String object with other thread
final Exchanger> exchanger = new Exchanger>();
Thread producer = new Thread( "Producer : " ){
@Override
public void run(){
ArrayDeque(); Deque stack = new ArrayDeque();
//producer thread insert elments into stack
while (stack.isEmpty()) {
stack.add(System.nanoTime()% 1000 );
//if stack is not empty then exchange it to consumer thread
try {
System.out.println(Thread.currentThread().getName()
+ " ready to exchange : " + stack); <br> // Exchanger return other Thread's object
stack = exchanger.exchange(stack);
System.out.println(Thread.currentThread().getName()
+ " got : " + stack);
} catch (InterruptedException ie) { ie.printStackTrace(); } (InterruptedException ie) { ie.printStackTrace(); }
}
}
};
Thread consumer = new Thread( "Consumer : " ){
@Override
public void run(){
ArrayDeque(); Deque stack = new ArrayDeque();
//consumer thread takes object from stack and prints
do {
//if stack is empty then exchange it to producer for refill
try {
System.out.println(Thread.currentThread().getName()
+ " ready to exchange : " + stack);
stack = exchanger.exchange(stack);
System.out.println(Thread.currentThread().getName()
+ " got : " + stack);
stack.remove();
} catch (InterruptedException ie) { ie.printStackTrace(); } (InterruptedException ie) { ie.printStackTrace(); }
} while (stack.isEmpty()) ;
}
};
producer.start(); <br> //sleeping before starting consumer to give producer time to produce
Thread.sleep( 1000 ); consumer.start();
} } Output: Producer : ready to exchange : [ 247 ] Consumer : ready to exchange : [] Producer : got : [] Consumer : got : [ 247 ] Producer : ready to exchange : [ 692 ] Consumer : ready to exchange : [] Consumer : got : [ 692 ] Consumer : ready to exchange : [] Producer : got : [] <br> 代码和输出说明
如果看上面的示例，所有代码都在main方法内部。 之所以使Exchanger实例成为最终实例，是因为我们要从匿名内部类访问它们，并且只能从匿名内部类访问最终局部变量。
后来，我们创建了两个线程， Producer和Consumer 。 生产者检查队列，如果队列为空，则将当前nano时间的最后三位相加并调用exchange（）方法。
现在，直到消费者线程到达交换点，我的意思是直到生产者线程调用exchange（）方法，生产者线程才会被阻塞。
使用者到达后，双方互相交换堆栈并从exchange（）方法返回。 此时，生产者有一个空的消费者堆栈，而消费者有一个非空的生产者堆栈，我的意思是，他们有彼此的对象 。
为了理解哪个线程正在交换哪个堆栈，我们在每个线程交换之前和之后打印堆栈的内容。 如果您查看输出，这是不言自明的。
顺便提一下，与线程一样，不能保证以相同的顺序获得输出。 在第三次迭代中，您可以看到使用者具有一个已清空的堆栈，甚至可以在安排生产者线程并从交换方法返回之前，准备交换空堆栈。
这就是如何在Java中使用Exchanger的全部内容。 交换器类是一个很好的简单同步工具，非常适合于协调两个线程。 应该使用交换器来实现具有一个生产者和一个消费者的生产者-消费者模式。 如果您想了解有关Java并发类的更多信息，建议您检查以下资源：
进阶学习
完整的Java Masterclass Java多线程，并发和性能优化 Java并发实践–本书 将并发和多线程应用于常见的Java模式
您可能喜欢的其他Java并发文章
- 2020 Java开发人员路线图 （ 路线图 ）
- Java并发之前发生了什么？ （ 回答 ）
- 10个Java多线程和并发最佳实践（ 文章 ）
- Java中的前50个多线程和并发问题（ 问题 ）
- 掌握Java并发性的5大书籍（ 书籍 ）
- 10个面向初学者和中级开发者的免费Java课程（ 课程 ）
- 如何避免Java死锁？ （ 回答 ）
- 了解Java程序中的数据和代码流（ 回答 ）
- Java Concurrency in Practice是否在2020年仍然有效（ 回答 ）
- Java中CyclicBarrier和CountDownLatch之间的区别？ （ 回答 ）
- 10个技巧，成为2020年的一个更好的Java开发（ 提示 ）
- 如何使用wait-notify在Java中进行线程间通信？ （ 回答 ）
- 深入学习Java多线程的前5门课程（ 课程 ）
感谢您到目前为止阅读本文。 如果您喜欢此Java并发教程，请与您的朋友和同事分享。 如果您有任何问题或反馈，请留下笔记。
PS –如果您是Java世界的新手，并且想与Concurrency一起学习核心概念，但是想找一些免费的入门课程，那么您也可以在Udemy上查看此免费的Java Multithreading课程 。 这也是学习Java并发性的一门很好的免费课程。
翻译自: https://www.javacodegeeks.com/2020/05/how-to-use-exchanger-in-java-with-example.html
