如何控制线程的执行顺序

线程的执行是随机的，由CPU控制，但是我们可以通过以下的方法对多线程进行可控顺序的执行：

1.使用join方法：让主线程等待子线程的执行完成

工作原理是：在当前线程调用其它线程的join会让当前线程阻塞等待join线程的执行完成，不停检查thread是否存活，如果存活则让当前线程一直wait，直到thread线程终止，线程的this.notifyAll 就会被调用。

public classTest{

public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(new MyThread1());

        Thread t2 = new Thread(new MyThread2());

        Thread t3 = new Thread(new MyThread3());

        t1.start();

        t1.join();

        t2.start();

        t2.join();

        t3.start();

    }

}

classMyThread1implementsRunnable{    @Override

    public void run() {

        System.out.println("I am thread 1");

    }

}classMyThread2implementsRunnable{    @Override

    public void run() {

        System.out.println("I am thread 2");

    }

}classMyThread3implementsRunnable{    @Override

    public void run() {

        System.out.println("I am thread 3");

    }

}

2.使用CountDownLatch，它与join效果是一样的，都是用来阻塞其他线程的执行，等待本线程执行完，但是它采用的是计数器方式，如果发现计数器为0就结束阻塞继续执行下去。他们的区别在于join需要等待线程的完全执行完才会notifyall其他线程，而CountDownLatch不需要，它可以分阶段，只要计数器为0。 countDownLatch.countDown(); 

public class Worker extends Thread {  

//工作者名  

private String name;  

//第一阶段工作时间  

private long time;  

private CountDownLatch countDownLatch;  

public Worker(String name, long time, CountDownLatch countDownLatch) {  

this.name = name;  

this.time = time;  

this.countDownLatch = countDownLatch;  

    }  

@Override  

public void run() {  

// TODO 自动生成的方法存根  

try {  

System.out.println(name+"开始工作");  

            Thread.sleep(time);  

System.out.println(name+"第一阶段工作完成");  

            countDownLatch.countDown();  

Thread.sleep(2000); //这里就姑且假设第二阶段工作都是要2秒完成  

System.out.println(name+"第二阶段工作完成");  

System.out.println(name+"工作完成，耗费时间="+(time+2000));  

}catch (InterruptedException e) {  

// TODO 自动生成的 catch 块  

            e.printStackTrace();  

        }     

    }  

}  

package com.concurrent.test5;  

import java.util.concurrent.CountDownLatch;  

public class Test {  

public static void main(String[] args) throws InterruptedException {  

// TODO 自动生成的方法存根  

CountDownLatch countDownLatch =new CountDownLatch(2);  

Worker worker0 =new Worker("worker0", (long) (Math.random()*2000+3000), countDownLatch);  

Worker worker1 =new Worker("worker1", (long) (Math.random()*2000+3000), countDownLatch);  

Worker worker2 =new Worker("worker2", (long) (Math.random()*2000+3000), countDownLatch);  

        worker0.start();  

        worker1.start();      

        countDownLatch.await();  

System.out.println("准备工作就绪");  

        worker2.start();  

    }  

}  

3.使用Excutors.newSingleThreadExecutor()：这是单线程的线程池，底层原理是一个先进先出的队列

public classTest{ private static ExecutorService executor = Executors.newSingleThreadExecutor();

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(new MyThread1());

        Thread t2 = new Thread(new MyThread2());

        Thread t3 = new Thread(new MyThread3());

        executor.submit(t1);

        executor.submit(t2);

        executor.submit(t3);

        executor.shutdown();

    }

}

classMyThread1implementsRunnable{    @Override

    public void run() {

        System.out.println("I am thread 1");

    }

}

classMyThread2implementsRunnable{    @Override

    public void run() {

        System.out.println("I am thread 2");

    }

}

classMyThread3implementsRunnable{    @Override

    public void run() {

        System.out.println("I am thread 3");

    }

}