假设有线程1/线程2/线程3，线程3必须在线程1/线程2执行完成之后开始执行，有两种方式可实现
- Thread类的join方法：使宿主线程阻塞指定时间或者直到寄生线程执行完毕
- CountDownLatch类：指定计数器，当计数器清零即取消阻塞
package com.concurrent.test; import java.util.concurrent.CountDownLatch; import org.junit.Assert;
import org.junit.Test; /**
* 规定线程的执行顺序
*/
public class ThreadOrderTest { private long millisUnit = 1000;
private int count = 2; class ThreadOrder {
/*
* join方法使多个线程依次执行
*/
public long preserveOrderViaJoin() throws InterruptedException {
long startMillis = System.currentTimeMillis();
Thread tmp; for (int i = 0; i < count; i++) {
tmp = new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(millisUnit);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "join-" + i);
tmp.start();
tmp.join();//不停地监测线程是否执行完成，执行完成才继续往下
}
return System.currentTimeMillis() - startMillis;
} /*
* CountdownLatch可同时阻塞多个线程，但它们可并发执行
*/
public long preserveOrderViaCountdownLatch() throws InterruptedException {
long startMillis = System.currentTimeMillis();
final CountDownLatch countDownLatch = new CountDownLatch(count);
for (int i = 0; i < count; i++) {
new Thread(new Runnable() { @Override
public void run() {
try {
Thread.sleep(millisUnit);
} catch (InterruptedException e) {
e.printStackTrace();
}
//只要计数器清零，等待的线程就可以开始执行，于是可以达到并发的效果
countDownLatch.countDown();
}
},"countDownLatch-" + i).start();
}
countDownLatch.await();
return System.currentTimeMillis() - startMillis; }
} @Test
public void testPreserveOrderViaJoin() throws InterruptedException {
ThreadOrder threadOrder = new ThreadOrder();
Assert.assertEquals(count, threadOrder.preserveOrderViaJoin() / millisUnit);
} @Test
public void testPreserveOrderViaCountdownLatch() throws InterruptedException {
ThreadOrder threadOrder = new ThreadOrder();
Assert.assertEquals(1, threadOrder.preserveOrderViaCountdownLatch() / millisUnit);
}
}