三个线程顺序执行的实现方法是什么

本篇内容主要讲解“三个线程顺序执行的实现方法是什么”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“三个线程顺序执行的实现方法是什么”吧!

先说下要求，就是三个线程，假设是线程 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());         }     } }

到此，相信大家对“三个线程顺序执行的实现方法是什么”有了更深的了解，不妨来实际操作一番吧！这里是编程网网站，更多相关内容可以进入相关频道进行查询，关注我们，继续学习！