先说一下为什么会有这样的要求，如果是简单的要求按顺序执行代码，直接一行行写下来就行了。但是接口调用我们一般都放在工作线程里面，而且有时候需要拿一个接口返回的参数去请求另一个接口，这就需要控制线程按某种顺序执行。
方法1：join()
public class A1 extends Thread {
@Override
public void run() {
try {
System.out.println("--- thread A1 start ---");
sleep((long) (Math.random() * 30));
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("--- thread A1 end ---");
}
}
public class A2 extends Thread {
@Override
public void run() {
try {
System.out.println("--- thread A2 start ---");
sleep((long) (Math.random() * 30));
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("--- thread A2 end ---");
}
}
public class A3 extends Thread {
@Override
public void run() {
try {
System.out.println("--- thread A3 start ---");
sleep((long) (Math.random() * 30));
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("--- thread A3 end ---");
}
}
public class OrderTest {
public static void main(String[] args) {
try {
A1 a1 = new A1();
a1.start();
a1.join();
A2 a2 = new A2();
a2.start();
a2.join();
A3 a3 = new A3();
a3.start();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
// 控制台输出：
--- thread A1 start ---
--- thread A1 end ---
--- thread A2 start ---
--- thread A2 end ---
--- thread A3 start ---
--- thread A3 end ---
a1.start()使a1进入就绪状态，a1和主线程都可能抢到CPU执行权，a1.join()使a1线程独占CPU，主线程要等a1执行完才能执行a2的初始化和a2.start()等后续代码。另外，把
a2的初始化和a2.join()放在a3的run()里面的第一行（即执行a3的逻辑代码前），把a1的初始化和a1.join()放在a2的run()里面的第一行，也能让a1、a2、a3顺序执行，效果和上述代码相同。
方法2：wait() & notify()
public class B1 extends Thread{
@Override
public void run() {
synchronized (this){
try {
System.out.println("--- thread B1 start ---");
sleep((long) (Math.random() * 30));
System.out.println("--- thread B1 end ---");
notify();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class B2 extends Thread {
@Override
public void run() {
B1 b1 = new B1();
b1.start();
synchronized (b1){
try {
b1.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
synchronized (this){
try {
System.out.println("--- thread B2 start ---");
sleep((long) (Math.random() * 30));
System.out.println("--- thread B2 end ---");
notify();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class B3 extends Thread {
@Override
public void run() {
B2 b2 = new B2();
b2.start();
synchronized (b2){
try {
b2.wait();
System.out.println("--- thread B3 start ---");
sleep((long) (Math.random() * 30));
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("--- thread B3 end ---");
}
}
}
public class OrderTest {
public static void main(String[] args) {
new B3().start();
}
}
// 控制台输出：
--- thread B1 start ---
--- thread B1 end ---
--- thread B2 start ---
--- thread B2 end ---
--- thread B3 start ---
--- thread B3 end ---
需要注意的是，线程
B2中调用b1.wait()的时候不是让b1对象等待，而是让获取到b1对象同步锁的当前线程等待。这里面的「当前线程」指的就是线程B2了。线程
B1中的notify()，唤醒的是在当前对象上等待的线程（其实这里的notify()相当于this.notiify()）。
B2线程的run()里面，执行第一个synchronized代码块的时候，当前线程wait了，当被唤醒的时候继续执行后续代码（即第二个synchronized代码块）；B3被唤醒后执行b2.wait()后面的代码：System.out.println("--- thread B3 start ---");等。
方法3：线程池
public class OrderTest {
public static void main(String[] args) {
A1 a1 = new A1();
A2 a2 = new A2();
A3 a3 = new A3();
ExecutorService single = Executors.newSingleThreadExecutor();
single.submit(a1);
single.submit(a2);
single.submit(a3);
single.shutdown();
}
}
// 控制台输出：
--- thread A1 start ---
--- thread A1 end ---
--- thread A2 start ---
--- thread A2 end ---
--- thread A3 start ---
--- thread A3 end ---
newSingleThreadExecutor只包含一个线程，而且可以保证线程按顺序执行。
方法4
最容易想到的办法，在一个线程的run()里面的结尾处初始化并启动另一个线程（thread.start()），这个简单就补贴代码了。
