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

能想起来几种呢?

先说下要求，就是三个线程，假设是线程 1，2，3， 现在的要求是：必须是线程 1 先执行，然后线程 2 再执行，最后是线程 3 执行，然后有几种实现方法呢?

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

[[344833]]

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()); 
  
  
  
        } 
  
  
  
    } 
  
  
  
} 
 
 
 

 

分享题目：面试官：三个线程顺序执行，你来说说有几种实现方式？
URL网址：http://zsjierui.cn/article/cdseehp.html