Exchanger es la clase de sincronización más interesante de Java . Facilita el intercambio de elementos entre un par de hilos creando un punto de sincronización . Simplifica el intercambio de datos entre dos hilos. Su funcionamiento es simple: simplemente espera hasta que dos subprocesos distintos llamen a su método exchange() . Cuando eso ocurre, intercambia los datos proporcionados por los subprocesos. También se puede ver como SynchronousQueue bidireccional . Es una clase genérica que se declara de la siguiente manera.
Sintaxis de clase:
Exchanger<V>
Aquí, V especifica el tipo de datos que se intercambian.
Jerarquía de clases
java.lang.Object ↳ java.util.concurrent.Exchanger<V>
Constructor:
- Exchanger() : crea un nuevo objeto Exchanger con valores predeterminados para sus miembros.
Métodos:
- intercambio (V x) : cuando se invoca, esta función hace que el subproceso actual suspenda su ejecución y espere a que otro subproceso llame a su método de intercambio. Cuando otro subproceso llama a su método de intercambio, los subprocesos intercambian sus datos y se reanuda la ejecución.
Sintaxis:
public V exchange(V x) throws InterruptedException
- intercambio (V x, tiempo de espera largo, unidad de unidad de tiempo) : cuando se invoca, esta función hace que el subproceso actual suspenda su ejecución y espere a que otro subproceso llame a su método de intercambio. Cuando otro subproceso llama a su método de intercambio, los subprocesos intercambian sus datos y se reanuda la ejecución. El subproceso espera solo la duración especificada por el argumento de tiempo de espera y, en caso de que transcurra la duración del tiempo de espera, se lanza una TimeoutException.
Sintaxis:
public V exchange(V x, long timeout, TimeUnit unit) throws InterruptedException, TimeoutException
Ejemplo para demostrar el funcionamiento de la clase Exchanger:
import java.util.concurrent.Exchanger;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
public class ExchangerDemo {
public static void main(String[] args)
{
Exchanger<String> exchanger = new Exchanger<>();
new UseString(exchanger);
new MakeString(exchanger);
}
}
// A thread that makes a string
class MakeString implements Runnable {
Exchanger<String> ex;
String str;
MakeString(Exchanger<String> ex)
{
this.ex = ex;
str = new String();
new Thread(this).start();
}
public void run()
{
char ch = 'A';
try {
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 5; j++) {
str += ch++;
}
if (i == 2) {
// Exchange the buffer and
// only wait for 250 milliseconds
str
= ex.exchange(str,
250,
TimeUnit.MILLISECONDS);
continue;
}
// Exchange a full buffer for an empty one
str = ex.exchange(str);
}
}
catch (InterruptedException e) {
System.out.println(e);
}
catch (TimeoutException t) {
System.out.println("Timeout Occurred");
}
}
}
// A thread that uses a string
class UseString implements Runnable {
Exchanger<String> ex;
String str;
UseString(Exchanger<String> ex)
{
this.ex = ex;
new Thread(this).start();
}
public void run()
{
try {
for (int i = 0; i < 3; i++) {
if (i == 2) {
// Thread sleeps for 500 milliseconds
// causing timeout
Thread.sleep(500);
continue;
}
// Exchange an empty buffer for a full one
str = ex.exchange(new String());
System.out.println("Got: " + str);
}
}
catch (InterruptedException e) {
System.out.println(e);
}
}
}
Got: ABCDE Got: FGHIJ Timeout Occurred
Referencia: https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Exchanger.html
Publicación traducida automáticamente
Artículo escrito por CharchitKapoor y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA