Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## edu.emory.mathcs.backport.java.util.concurrent
Class Exchanger

    java.lang.Object
      edu.emory.mathcs.backport.java.util.concurrent.Exchanger

public class Exchanger
extends java.lang.Object

A synchronization point at which threads can pair and swap elements within pairs. Each thread presents some object on entry to the `exchange` method, matches with a partner thread, and receives its partner's object on return.

Sample Usage: Here are the highlights of a class that uses an to swap buffers between threads so that the thread filling the buffer gets a freshly emptied one when it needs it, handing off the filled one to the thread emptying the buffer.

           } catch (InterruptedException ex) { ... handle ... }
         }
       }

       class EmptyingLoop implements Runnable {
         public void run() {
           DataBuffer currentBuffer = initialFullBuffer;
           try {
             while (currentBuffer != null) {
               takeFromBuffer(currentBuffer);
               if (currentBuffer.isEmpty())
                 currentBuffer = exchanger.exchange(currentBuffer);
             }
           } catch (InterruptedException ex) { ... handle ...}
         }
       }

       void start() {
         new Thread(new FillingLoop()).start();
         new Thread(new EmptyingLoop()).start();
       }
     }
     }

Memory consistency effects: For each pair of threads that successfully exchange objects via an , actions prior to the in each thread happen-before those subsequent to a return from the corresponding in the other thread.

Since:
  1.5
Author:
  Doug Lea and Bill Scherer and Michael Scott

Constructor Summary
`Exchanger()` Creates a new Exchanger.

Method Summary
`java.lang.Object` | `exchange(java.lang.Object x)` Waits for another thread to arrive at this exchange point (unless it is `interrupted`), and then transfers the given object to it, receiving its object in return.
`java.lang.Object` | `exchange(java.lang.Object x, long timeout, TimeUnit unit)` Waits for another thread to arrive at this exchange point (unless the current thread is `interrupted` or the specified waiting time elapses), and then transfers the given object to it, receiving its object in return.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### Exchanger

    public Exchanger()

  Creates a new Exchanger.

Method Detail

### exchange

    public java.lang.Object exchange(java.lang.Object x)
                              throws java.lang.InterruptedException

  Waits for another thread to arrive at this exchange point (unless it is `interrupted`), and then transfers the given object to it, receiving its object in return.

  If another thread is already waiting at the exchange point then it is resumed for thread scheduling purposes and receives the object passed in by the current thread. The current thread returns immediately, receiving the object passed to the exchange by that other thread.

  If no other thread is already waiting at the exchange then the current thread is disabled for thread scheduling purposes and lies dormant until one of two things happens:

  - Some other thread enters the exchange; or
  - Some other thread `interrupts` the current thread.

  If the current thread:

  - has its interrupted status set on entry to this method; or
  - is `interrupted` while waiting for the exchange,
  then `InterruptedException` is thrown and the current thread's interrupted status is cleared.

  Parameters:
    `x` - the object to exchange
  Returns:
    the object provided by the other thread
  Throws:
    `java.lang.InterruptedException` - if the current thread was interrupted while waiting

### exchange

    public java.lang.Object exchange(java.lang.Object x,
                                     long timeout,
                                     TimeUnit unit)
                              throws java.lang.InterruptedException,
                                     TimeoutException

  Waits for another thread to arrive at this exchange point (unless the current thread is `interrupted` or the specified waiting time elapses), and then transfers the given object to it, receiving its object in return.

  If another thread is already waiting at the exchange point then it is resumed for thread scheduling purposes and receives the object passed in by the current thread. The current thread returns immediately, receiving the object passed to the exchange by that other thread.

  If no other thread is already waiting at the exchange then the current thread is disabled for thread scheduling purposes and lies dormant until one of three things happens:

  - Some other thread enters the exchange; or
  - Some other thread `interrupts` the current thread; or
  - The specified waiting time elapses.

  If the current thread:

  - has its interrupted status set on entry to this method; or
  - is `interrupted` while waiting for the exchange,
  then `InterruptedException` is thrown and the current thread's interrupted status is cleared.

  If the specified waiting time elapses then `TimeoutException` is thrown. If the time is less than or equal to zero, the method will not wait at all.

  Parameters:
    `x` - the object to exchange
    `timeout` - the maximum time to wait
    `unit` - the time unit of the `timeout` argument
  Returns:
    the object provided by the other thread
  Throws:
    `java.lang.InterruptedException` - if the current thread was interrupted while waiting
    `TimeoutException` - if the specified waiting time elapses before another thread enters the exchange

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD