Stay organized with collections
Save and categorize content based on your preferences.
Exchanger
open class Exchanger<V : Any!>
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. An Exchanger may be viewed as a bidirectional form of a SynchronousQueue. Exchangers may be useful in applications such as genetic algorithms and pipeline designs.
Sample Usage: Here are the highlights of a class that uses an Exchanger 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.
<code>class FillAndEmpty {
Exchanger<DataBuffer> exchanger = new Exchanger<>();
DataBuffer initialEmptyBuffer = ...; // a made-up type
DataBuffer initialFullBuffer = ...;
class FillingLoop implements Runnable {
public void run() {
DataBuffer currentBuffer = initialEmptyBuffer;
try {
while (currentBuffer != null) {
addToBuffer(currentBuffer);
if (currentBuffer.isFull())
currentBuffer = exchanger.exchange(currentBuffer);
}
} 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();
}
}</code>
Memory consistency effects: For each pair of threads that successfully exchange objects via an Exchanger, actions prior to the exchange() in each thread happen-before those subsequent to a return from the corresponding exchange() in the other thread.
Summary
| Public constructors |
|
Creates a new Exchanger.
|
| Public methods |
| open V |
Waits for another thread to arrive at this exchange point (unless the current thread is interrupted), and then transfers the given object to it, receiving its object in return.
|
| open V |
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.
|
Public constructors
Exchanger
Exchanger()
Creates a new Exchanger.
Public methods
exchange
open fun exchange(x: V): V
Waits for another thread to arrive at this exchange point (unless the current thread 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 |
V: the object to exchange |
| Return |
V |
the object provided by the other thread |
| Exceptions |
java.lang.InterruptedException |
if the current thread was interrupted while waiting |
exchange
open fun exchange(
x: V,
timeout: Long,
unit: TimeUnit!
): V
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 |
V: the object to exchange |
timeout |
Long: the maximum time to wait |
unit |
TimeUnit!: the time unit of the timeout argument |
| Return |
V |
the object provided by the other thread |
| Exceptions |
java.lang.InterruptedException |
if the current thread was interrupted while waiting |
java.util.concurrent.TimeoutException |
if the specified waiting time elapses before another thread enters the exchange |
Content and code samples on this page are subject to the licenses described in the Content License. Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.
Last updated 2025-02-10 UTC.
[[["Easy to understand","easyToUnderstand","thumb-up"],["Solved my problem","solvedMyProblem","thumb-up"],["Other","otherUp","thumb-up"]],[["Missing the information I need","missingTheInformationINeed","thumb-down"],["Too complicated / too many steps","tooComplicatedTooManySteps","thumb-down"],["Out of date","outOfDate","thumb-down"],["Samples / code issue","samplesCodeIssue","thumb-down"],["Other","otherDown","thumb-down"]],["Last updated 2025-02-10 UTC."],[],[],null,["# Exchanger\n\nAdded in [API level 1](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels)\n\nExchanger\n=========\n\n```\nopen class Exchanger\u003cV : Any!\u003e\n```\n\n|---|-------------------------------------|\n| [kotlin.Any](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-any/index.html) ||\n| ↳ | [java.util.concurrent.Exchanger](#) |\n\nA 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. An Exchanger may be viewed as a bidirectional form of a [SynchronousQueue](/reference/kotlin/java/util/concurrent/SynchronousQueue). Exchangers may be useful in applications such as genetic algorithms and pipeline designs.\n\n**Sample Usage:** Here are the highlights of a class that uses an `Exchanger` 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. \n\n```kotlin\n\u003ccode\u003eclass FillAndEmpty {\n Exchanger<DataBuffer> exchanger = new Exchanger<>();\n DataBuffer initialEmptyBuffer = ...; // a made-up type\n DataBuffer initialFullBuffer = ...;\n \n class FillingLoop implements Runnable {\n public void run() {\n DataBuffer currentBuffer = initialEmptyBuffer;\n try {\n while (currentBuffer != null) {\n addToBuffer(currentBuffer);\n if (currentBuffer.isFull())\n currentBuffer = exchanger.exchange(currentBuffer);\n }\n } catch (InterruptedException ex) { ... handle ...}\n }\n }\n \n class EmptyingLoop implements Runnable {\n public void run() {\n DataBuffer currentBuffer = initialFullBuffer;\n try {\n while (currentBuffer != null) {\n takeFromBuffer(currentBuffer);\n if (currentBuffer.isEmpty())\n currentBuffer = exchanger.exchange(currentBuffer);\n }\n } catch (InterruptedException ex) { ... handle ...}\n }\n }\n \n void start() {\n new Thread(new FillingLoop()).start();\n new Thread(new EmptyingLoop()).start();\n }\n }\u003c/code\u003e\n```\n\nMemory consistency effects: For each pair of threads that successfully exchange objects via an `Exchanger`, actions prior to the `exchange()` in each thread [*happen-before*](/reference/kotlin/java/util/concurrent/package-summary#MemoryVisibility) those subsequent to a return from the corresponding `exchange()` in the other thread.\n\nSummary\n-------\n\n| Public constructors ||\n|--------------------------------------------------------|---|\n| [Exchanger](#Exchanger())`()` Creates a new Exchanger. |\n\n| Public methods ||\n|--------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| open V | [exchange](#exchange(java.util.concurrent.Exchanger.V))`(`x:` `V`)` Waits for another thread to arrive at this exchange point (unless the current thread is [interrupted](../../lang/Thread.html#interrupt())), and then transfers the given object to it, receiving its object in return. |\n| open V | [exchange](#exchange(java.util.concurrent.Exchanger.V,%20kotlin.Long,%20java.util.concurrent.TimeUnit))`(`x:` `V`, `timeout:` `[Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html)`, `unit:` `[TimeUnit](/reference/kotlin/java/util/concurrent/TimeUnit)!`)` Waits for another thread to arrive at this exchange point (unless the current thread is [interrupted](../../lang/Thread.html#interrupt()) or the specified waiting time elapses), and then transfers the given object to it, receiving its object in return. |\n\nPublic constructors\n-------------------\n\n### Exchanger\n\nAdded in [API level 1](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels) \n\n```\nExchanger()\n```\n\nCreates a new Exchanger.\n\nPublic methods\n--------------\n\n### exchange\n\nAdded in [API level 1](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels) \n\n```\nopen fun exchange(x: V): V\n```\n\nWaits for another thread to arrive at this exchange point (unless the current thread is [interrupted](../../lang/Thread.html#interrupt())), and then transfers the given object to it, receiving its object in return.\n\nIf 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.\n\nIf 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:\n\n- Some other thread enters the exchange; or\n- Some other thread [interrupts](../../lang/Thread.html#interrupt()) the current thread.\n\nIf the current thread:\n\n- has its interrupted status set on entry to this method; or\n- is [interrupted](../../lang/Thread.html#interrupt()) while waiting for the exchange,\n\nthen [InterruptedException](../../lang/InterruptedException.html#) is thrown and the current thread's interrupted status is cleared.\n\n| Parameters ||\n|-----|---------------------------|\n| `x` | V: the object to exchange |\n\n| Return ||\n|---|-----------------------------------------|\n| V | the object provided by the other thread |\n\n| Exceptions ||\n|----------------------------------|-----------------------------------------------------|\n| `java.lang.InterruptedException` | if the current thread was interrupted while waiting |\n\n### exchange\n\nAdded in [API level 1](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels) \n\n```\nopen fun exchange(\n x: V, \n timeout: Long, \n unit: TimeUnit!\n): V\n```\n\nWaits for another thread to arrive at this exchange point (unless the current thread is [interrupted](../../lang/Thread.html#interrupt()) or the specified waiting time elapses), and then transfers the given object to it, receiving its object in return.\n\nIf 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.\n\nIf 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:\n\n- Some other thread enters the exchange; or\n- Some other thread [interrupts](../../lang/Thread.html#interrupt()) the current thread; or\n- The specified waiting time elapses.\n\nIf the current thread:\n\n- has its interrupted status set on entry to this method; or\n- is [interrupted](../../lang/Thread.html#interrupt()) while waiting for the exchange,\n\nthen [InterruptedException](../../lang/InterruptedException.html#) is thrown and the current thread's interrupted status is cleared.\n\nIf the specified waiting time elapses then [TimeoutException](/reference/kotlin/java/util/concurrent/TimeoutException) is thrown. If the time is less than or equal to zero, the method will not wait at all.\n\n| Parameters ||\n|-----------|--------------------------------------------------------------------------------------------------------|\n| `x` | V: the object to exchange |\n| `timeout` | [Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html): the maximum time to wait |\n| `unit` | [TimeUnit](/reference/kotlin/java/util/concurrent/TimeUnit)!: the time unit of the `timeout` argument |\n\n| Return ||\n|---|-----------------------------------------|\n| V | the object provided by the other thread |\n\n| Exceptions ||\n|-----------------------------------------|---------------------------------------------------------------------------------|\n| `java.lang.InterruptedException` | if the current thread was interrupted while waiting |\n| `java.util.concurrent.TimeoutException` | if the specified waiting time elapses before another thread enters the exchange |"]]
