Exchage可以作为两个线程之间通信的通道,简单使用可以看一下
jdk中线程间的数据交换Exchanger
如果某一个线程先到达通道,在等待另一线程到达通道进行数据交换的过程中,处于等待状态的线程会因为exchange方法放弃对线程的控制吗。答案是不会。到达exchange方法之后。此线程依然会持有这个线程,而不是把这个线程控制权暂时交出去。与sleep相像,与wait不同
验证Demo:
如果某一个线程先到达通道,在等待另一线程到达通道进行数据交换的过程中,处于等待状态的线程会因为exchange方法放弃对线程的控制吗。答案是不会。到达exchange方法之后。此线程依然会持有这个线程,而不是把这个线程控制权暂时交出去。与sleep相像,与wait不同
验证Demo:
package sync;
import java.util.concurrent.Callable;
import java.util.concurrent.Exchanger;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
public class ExchangerDemo {
public static void main(String[] args) {
final Exchanger<String> ec = new Exchanger<>();
final long time1 = System.currentTimeMillis();
Callable<String> c1 = new Callable<String>() {
@Override
public String call() throws Exception {
System.out.println("c1 start");
Thread.sleep(1000);
System.out.println("c1 exchange start:" + (System.currentTimeMillis() - time1));
System.out.println("c1 get:" + ec.exchange("c1 to other")); // 处于等待状态,直到另外一个线程开始交换
System.out.println("c1 exchange end");
return "the return of c1";
}
};
Runnable r1 = new Runnable() {
@Override
public void run() {
try {
System.out.println("r1 start");
Thread.sleep(5000);
System.out.println("r1 exchange start:" + (System.currentTimeMillis() - time1));
System.out.println("r1 get:" + ec.exchange("r1 to other"));;
System.out.println("r1 exchange end");
} catch (InterruptedException e) {
System.out.println("r1 exchange exception");
e.printStackTrace();
}
}
};
ExecutorService eService = Executors.newFixedThreadPool(2);
Runnable r2 = new Runnable() {
@Override
public void run() {
System.out.println("r2 is done:" + (System.currentTimeMillis() - time1));
}
};
eService.submit(c1);
eService.submit(r1);
eService.submit(r2);
}
}
执行结果:
c1 start
r1 start
c1 exchange start:1011
r1 exchange start:5011
r1 get:c1 to other
r1 exchange end
c1 get:r1 to other
c1 exchange end
r2 is done:5011