java三个线程依次执行_面试官：三个线程顺序执行，你来说说有几种实现方式？...

每天早上七点三十，准时推送干货

能想起来几种呢？

先说下要求，就是三个线程，假设是线程 1，2，3， 现在的要求是：必须是线程 1 先执行，然后线程 2 再执行，最后是线程 3 执行

然后有几种实现方法呢？

其实它的本质就是实现，让线程 2，3 等待线程 1 执行完毕，所以重点就是有哪些方法可以让线程 2，3 等待

join

第一反应应该就是使用 join 方法，因为 join 本来就是支持这种机制的

比如，我在线程 B 中调用了线程 A 的 join 方法，那么线程 B 就会等线程 A 执行结束之后再执行

那么具体应该怎么使用嘞？

别慌嘛，我这里有例子，你瞅瞅：

public class ThreadLoopOne{    public static void main(String[] args){        Thread t1 = new Thread(new Work(null));        Thread t2 = new Thread(new Work(t1));        Thread t3 = new Thread(new Work(t2));        t1.start();        t2.start();        t3.start();    }    static class Work implements Runnable{        private Thread beforeThread;        public Work(Thread beforeThread){            this.beforeThread = beforeThread;        }        @Override        public void run(){            // 如果有线程,就 join 进来,没有的话就直接输出            if (beforeThread != null ){                try {                    beforeThread.join();                    System.out.println("thread start : " + Thread.currentThread().getName());                } catch (InterruptedException e) {                    e.printStackTrace();                }            }else{                System.out.println("thread start : " + Thread.currentThread().getName());            }        }    }}

CountDownLatch

刚才说了，本质就是让线程 B，C 等待线程 A 执行完毕

那么信号量就是一个不错的选择

如果想要实现的话，那大概就是下面这样：

public class ThreadLoopTwo{    public static void main(String[] args){        // 设置线程 1 的信号量为 0        CountDownLatch cOne = new CountDownLatch(0);        // 设置线程 2 的信号量为 1        CountDownLatch cTwo = new CountDownLatch(1);        // 设置线程 3 的信号量为 1        CountDownLatch cThree = new CountDownLatch(1);        // 因为 cOne 为 0 ,故 t1 可以直接执行        Thread t1 = new Thread(new Work(cOne,cTwo));        // 线程 t1 执行完毕之后,此时的 cTwo 为 0 , t2 开始执行        Thread t2 = new Thread(new Work(cTwo,cThree));        // 线程 t2 执行完毕,此时 cThree 为 0 , t3 开始执行        Thread t3 = new Thread(new Work(cThree,cThree));        t1.start();        t2.start();        t3.start();    }    static class Work implements Runnable{        CountDownLatch cOne;        CountDownLatch cTwo;        public Work(CountDownLatch cOne, CountDownLatch cTwo){            super();            this.cOne = cOne;            this.cTwo = cTwo;        }        @Override        public void run(){            try {                // 当前一个线程信号量为 0 时,才执行                cOne.await();                System.out.println("thread start : " + Thread.currentThread().getName());                // 后一个线程信号量减 1                cTwo.countDown();            } catch (InterruptedException e) {                e.printStackTrace();            }        }    }}

使用单个线程池

之所以线程 1，2，3 的执行顺序无法保证，是因为在编译器可能会去做一些优化，导致没有办法按照顺序执行

如果我们使用单个线程池去执行的话，那就没有这样的问题了

具体实现：

public class ThreadLoopThree{    public static void main(String[] args){        Thread t1 = new Thread(new Runnable() {            @Override            public void run(){                System.out.println("thread start : " + Thread.currentThread().getName() + " run one");            }        });        Thread t2 = new Thread(new Runnable() {            @Override            public void run(){                System.out.println("thread start : " + Thread.currentThread().getName() + " run two");            }        });        Thread t3 = new Thread(new Runnable() {            @Override            public void run(){                System.out.println("thread start : " + Thread.currentThread().getName() + " run three");            }        });        ExecutorService executor = Executors.newSingleThreadExecutor();        // 将线程依次加入到线程池中        executor.submit(t1);        executor.submit(t2);        executor.submit(t3);        // 及时将线程池关闭        executor.shutdown();    }}

CompletableFuture

如果使用 CompletableFuture 来实现的话，代码就非常简洁了

public class ThreadLoopFour{    public static void main(String[] args){        Thread t1 = new Thread(new Work());        Thread t2 = new Thread(new Work());        Thread t3 = new Thread(new Work());        CompletableFuture.runAsync(()-> t1.start())                .thenRun(()->t2.start())                .thenRun(()->t3.start());    }    static class Work implements Runnable{        @Override        public void run(){            System.out.println("thread start : " + Thread.currentThread().getName());        }    }}

最后感谢各位的阅读，才疏学浅，难免存在纰漏，如果你发现错误的地方，由于本号没有留言功能，还请你在后台留言指出，我对其加以修改。

最后谢谢大家支持~

最最后，重要的事再说一篇~

快来关注我呀~快来关注我呀~快来关注我呀~

< END >

如果大家喜欢我们的文章，欢迎大家转发，点击在看让更多的人看到。也欢迎大家热爱技术和学习的朋友加入的我们的知识星球当中，我们共同成长，进步。