exchanger_如何通过示例在Java中使用Exchanger

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 : []