如果两个线程在运行过程中需要交换彼此的信息，比如一个数据或者使用的空间，就需要用到 Exchanger 这个类，Exchanger 为线程交换信息提供了非常方便的途径，它可以作为两个线程交换对象的同步点，只有当每个线程都在进入 exchange() 方法并给出对象时，才能接受其他线程返回时给出的对象。
每次只能两个线程交换数据，如果有多个线程，也只有两个能交换数据。下面看个通俗的例子：一手交钱一首交货！
public
class
ExchangerTest
{
public
static
void
main
(
String
[]
args
)
{
ExecutorService
service
=
Executors
.
newCachedThreadPool
();
final
Exchanger
exchanger
=
new
Exchanger
();
//定义一个交换对象，用来交换数据
//开启一个线程执行任务
service
.
execute
(
new
Runnable
(){
@Override
public
void
run
()
{
try
{
String
data1
=
"海洛因"
;
System
.
out
.
println
(
"线程"
+
Thread
.
currentThread
().
getName
()
+
"正在把毒品"
+
data1
+
"拿出来"
);
Thread
.
sleep
((
long
)(
Math
.
random
()*
10000
));
//把要交换的数据传到exchange方法中，然后被阻塞，等待另一个线程与之交换。返回交换后的数据
String
data2
=
(
String
)
exchanger
.
exchange
(
data1
);
System
.
out
.
println
(
"线程"
+
Thread
.
currentThread
().
getName
()
+
"用海洛因换来了"
+
data2
);
}
catch
(
Exception
e
){
}
finally
{
service
.
shutdown
();
System
.
out
.
println
(
"交易完毕，拿着钱快跑！"
);
}
}
});
//开启另一个线程执行任务
service
.
execute
(
new
Runnable
(){
@Override
public
void
run
()
{
try
{
String
data1
=
"300万"
;
System
.
out
.
println
(
"线程"
+
Thread
.
currentThread
().
getName
()
+
"正在把"
+
data1
+
"拿出来"
);
Thread
.
sleep
((
long
)(
Math
.
random
()*
10000
));
String
data2
=
(
String
)
exchanger
.
exchange
(
data1
);
System
.
out
.
println
(
"线程"
+
Thread
.
currentThread
().
getName
()
+
"用300万弄到了"
+
data2
);
}
catch
(
Exception
e
){
}
finally
{
service
.
shutdown
();
System
.
out
.
println
(
"交易完毕，拿着海洛因快跑！"
);
}
}
});
}
}
从代码中我仿佛看到了两个人在交易毒品的场面……来看一下交易结果如何：
线程pool-1-thread-1正在把毒品海洛因拿出来
线程pool-1-thread-2正在把300万拿出来
线程pool-1-thread-2用300万弄到了海洛因
线程pool-1-thread-1用海洛因换来了300万
交易完毕，拿着海洛因快跑！
交易完毕，拿着钱快跑！
跑的倒是快，从运行结果来看，确实实现了数据的交换，这个只是交换一个基本类型的数据而已，它真正的用处不仅仅局限于此，比如我们可以交换一个对象，这就有用了，JDK 官方提到了一个高级的应用：
使用 Exchanger 在线程间交换缓冲区，因此，在需要时，填充缓冲区的线程获取一个新腾空的缓冲区，并将填满的缓冲区传递给腾空缓冲区的线程。
这就得根据实际情况了，思想和上面的一样，实际中肯定要定义一个缓冲区的类，然后两个线程之间交换的就是这个缓冲区的类即可，至于类中如何实现，就得看实际情况了。Exchanger 的使用就总结这么多吧~
如果两个线程在运行过程中需要交换彼此的信息，比如一个数据或者使用的空间，就需要用到 Exchanger 这个类，Exchanger 为线程交换信息提供了非常方便的途径，它可以作为两个线程交换对象的同步点，只有当每个线程都在进入 exchange() 方法并给出对象时，才能接受其他线程返回时给出的对象。
每次只能两个线程交换数据，如果有多个线程，也只有两个能交换数据。下面看个通俗的例子：一手交钱一首交货！
public
class
ExchangerTest
{
public
static
void
main
(
String
[]
args
)
{
ExecutorService
service
=
Executors
.
newCachedThreadPool
();
final
Exchanger
exchanger
=
new
Exchanger
();
//定义一个交换对象，用来交换数据
//开启一个线程执行任务
service
.
execute
(
new
Runnable
(){
@Override
public
void
run
()
{
try
{
String
data1
=
"海洛因"
;
System
.
out
.
println
(
"线程"
+
Thread
.
currentThread
().
getName
()
+
"正在把毒品"
+
data1
+
"拿出来"
);
Thread
.
sleep
((
long
)(
Math
.
random
()*
10000
));
//把要交换的数据传到exchange方法中，然后被阻塞，等待另一个线程与之交换。返回交换后的数据
String
data2
=
(
String
)
exchanger
.
exchange
(
data1
);
System
.
out
.
println
(
"线程"
+
Thread
.
currentThread
().
getName
()
+
"用海洛因换来了"
+
data2
);
}
catch
(
Exception
e
){
}
finally
{
service
.
shutdown
();
System
.
out
.
println
(
"交易完毕，拿着钱快跑！"
);
}
}
});
//开启另一个线程执行任务
service
.
execute
(
new
Runnable
(){
@Override
public
void
run
()
{
try
{
String
data1
=
"300万"
;
System
.
out
.
println
(
"线程"
+
Thread
.
currentThread
().
getName
()
+
"正在把"
+
data1
+
"拿出来"
);
Thread
.
sleep
((
long
)(
Math
.
random
()*
10000
));
String
data2
=
(
String
)
exchanger
.
exchange
(
data1
);
System
.
out
.
println
(
"线程"
+
Thread
.
currentThread
().
getName
()
+
"用300万弄到了"
+
data2
);
}
catch
(
Exception
e
){
}
finally
{
service
.
shutdown
();
System
.
out
.
println
(
"交易完毕，拿着海洛因快跑！"
);
}
}
});
}
}
从代码中我仿佛看到了两个人在交易毒品的场面……来看一下交易结果如何：
线程pool-1-thread-1正在把毒品海洛因拿出来 线程pool-1-thread-2正在把300万拿出来 线程pool-1-thread-2用300万弄到了海洛因 线程pool-1-thread-1用海洛因换来了300万 交易完毕，拿着海洛因快跑！ 交易完毕，拿着钱快跑！
跑的倒是快，从运行结果来看，确实实现了数据的交换，这个只是交换一个基本类型的数据而已，它真正的用处不仅仅局限于此，比如我们可以交换一个对象，这就有用了，JDK 官方提到了一个高级的应用：
使用 Exchanger 在线程间交换缓冲区，因此，在需要时，填充缓冲区的线程获取一个新腾空的缓冲区，并将填满的缓冲区传递给腾空缓冲区的线程。
这就得根据实际情况了，思想和上面的一样，实际中肯定要定义一个缓冲区的类，然后两个线程之间交换的就是这个缓冲区的类即可，至于类中如何实现，就得看实际情况了。Exchanger 的使用就总结这么多吧~
