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

能想起来几种呢?

先说下要求，就是三个线程，假设是线程 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://www.shufengxianlan.com/qtweb/news44/351494.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：创新互联

猜你还喜欢下面的内容