exchanger

大家好，如果您在并发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 Concurrency教程中，您将通过使用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 time的最后三位相加并调用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

exchanger