devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

线程顺序执行的8种方法，最后一种你用过吗？_线程顺序执行的方法

作者：IT小白 | 2024-03-06 10:11:20

赞

踩

线程顺序执行的方法

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/q258523454/article/details/117998310
 

假如有3个线程（A，B，C），怎么让它们按照指定的顺序执行任务呢？假设希望按照 A->B->C 的顺序执行。

本文将依次介绍8种方式

目录

1.Thread.join()

2.SingleThreadExecutor(单线程池)

3.object.wait/notify(等待通知)

4.ReentrantLock-Condition(重入锁)

5.CountDownLatch(减数器)/ CyclicBarrier(栅栏)

6.Semaphore(信号量)

7.FutureTask

8.猜一猜?

下面的代码可以直接复制，运行。

1.Thread.join()

这种方式不推荐，纯粹的是为了实现这功能。

@SneakyThrowspublic static void main(String[] args) {    // 创建三个线程 A,B,C    Thread threadA = new Thread(() -> System.out.println("A"), "A");    Thread threadB = new Thread(() -> System.out.println("B"), "B");    Thread threadC = new Thread(() -> System.out.println("C"), "C");​    // 使用 Thread.join() 等待线程执行完毕, 这种方式不优雅    threadA.start();    threadA.join();​    threadB.start();    threadB.join();​    threadC.start();    threadC.join();    System.exit(0);}

执行结果:

ABC

2.SingleThreadExecutor(单线程池)

用单个线程池来实现顺序执行，这种方式比较简单，就是利用单线程池的FIFO原理。

先定义一个Runnable

  1. @Slf4j
  2. public class MyRunnable implements Runnable {
  3.  
  4.     /**
  5.      * 自定义线程名
  6.      */
  7.     private String threadName;
  8.  
  9.     /**
  10.      * CountDownLatch指令
  11.      */
  12.     private CountDownLatch latch;
  13.  
  14.     public MyRunnable(String threadName, CountDownLatch latch) {
  15.         this.threadName = threadName;
  16.         this.latch = latch;
  17.     }
  18.  
  19.     @Override
  20.     public void run()
  21.     {
  22.         try {
  23.             // 等待 countDownLatch.countDown() 命名
  24.             latch.await();
  25.             System.out.println(threadName);
  26.         } catch (InterruptedException e) {
  27.             e.printStackTrace();
  28.         }
  29.     }
  30. }

创建单个线程池

  1. /**
  2.  * 利用单线程池达到顺序执行
  3.  * {@link java.util.concurrent.LinkedBlockingQueue} 保证了FIFO顺序
  4.  */
  5. public static void main(String[] args) {
  6.     ExecutorService executorService = Executors.newFixedThreadPool(1);
  7.     // CountDownLatch减数机制,countDown触发await,达到同时执行的目的
  8.     CountDownLatch latch = new CountDownLatch(1);
  9.  
  10.     List<String> threadNameList = Arrays.asList("A", "B", "C");
  11.     for (int i = 0; i < 3; i++) {
  12.         executorService.execute(new MyRunnable(threadNameList.get(i), latch));
  13.     }
  14.  
  15.     latch.countDown();
  16.     executorService.shutdown();
  17.     while (!executorService.isTerminated()) {
  18.         // 等待所有线程执行完成
  19.     }
  20.     System.exit(0);
  21. }

执行结果：A->B->C

3.object.wait/notify(等待通知)

不推荐这种方式，原因：不灵活

注意这里有坑，wait()的线程必须要先执行，否则其他线程notify()是无法唤醒的。换句话说，object的这种方式，锁的使用方式一定是先wait()再notify()。

为了简单说明，这里只写A，B两个线程，以A->B顺序执行的示例。

执行代码：

  1. @Slf4j
  2. public class Test {
  3.  
  4.     /**
  5.      * 使用 object.wait()/object.notify()
  6.      */
  7.     @SneakyThrows
  8.     public static void main(String[] args) {
  9.         final Object pv = new Object();
  10.  
  11.         ThreadB b = new ThreadB();
  12.         ThreadA a = new ThreadA(b);
  13.  
  14.         // 期望顺序 A->B
  15.         ExecutorService executorService = Executors.newFixedThreadPool(10);
  16.  
  17.         // 这里必须要让B先执行才能正常执行,否则会让B一直处于wait()
  18.         // 原因: 如果A先拿到对象锁,执行notify()无法唤醒B, 因为B还没有拿到对象锁,还没有执行wait()
  19.         // 因此: 同一个锁的执行顺序一定是 wait()-notify()
  20.         executorService.execute(b);
  21.         Thread.sleep(100);
  22.         executorService.execute(a);
  23.  
  24.  
  25.         // 停止接受新任务,当已有任务将执行完,关闭线程池
  26.         executorService.shutdown();
  27.         while (!executorService.isTerminated()) {
  28.             // 等待所有线程执行完成
  29.         }
  30.         System.exit(0);
  31.     }
  32.  
  33.     static class ThreadB implements Runnable {
  34.         @Override
  35.         public void run() {
  36.             synchronized (this) {
  37.                 try {
  38.                     log.info("B线程等待A线程 doing");
  39.                     // wait()的执行前提是当前线程获取了对象控制权,否则会报错:java.lang.IllegalMonitorStateException
  40.                     this.wait();
  41.                     log.info("B线程等待A线程 done");
  42.                 } catch (InterruptedException e) {
  43.                     e.printStackTrace();
  44.                 }
  45.                 log.info("B线程执行完成.");
  46.             }
  47.         }
  48.     }
  49.  
  50.     @AllArgsConstructor
  51.     static class ThreadA implements Runnable {
  52.         private final Object obj;
  53.  
  54.         @SneakyThrows
  55.         @Override
  56.         public void run() {
  57.             synchronized (obj) {
  58.                 // notify()不会立马释放对象锁,释放情景: 1.synchronized代码块执行完成; 2.主动释放 wait();
  59.                 obj.notify();
  60.                 log.info("A线程开始执行.");
  61.                 log.info("A线程执行完成.");
  62.             }
  63.         }
  64.     }
  65. }

 执行结果:

 B线程等待A线程 doing A线程开始执行. A线程执行完成. B线程等待A线程 done B线程执行完成.

4.ReentrantLock-Condition(重入锁)

这种方式比前一种方式灵活些。原理类似。

实现代码：

  1. @Slf4j
  2. public class Test {
  3.  
  4.     /**
  5.      * 重入锁实现(ReentrantLock-Condition)
  6.      */
  7.     @SneakyThrows
  8.     public static void main(String[] args) {
  9.  
  10.         ExecutorService executorService = Executors.newFixedThreadPool(3);
  11.  
  12.         final SequenceLock sequenceLock = new SequenceLock();
  13.         Runnable a = () -> sequenceLock.a();
  14.         Runnable b = () -> sequenceLock.b();
  15.         Runnable c = () -> sequenceLock.c();
  16.         executorService.execute(a);
  17.         executorService.execute(b);
  18.         executorService.execute(c);
  19.  
  20.         Thread.sleep(1000);
  21.         sequenceLock.getLock().lock();
  22.         try {
  23.             // 唤醒A线程,依次执行A,B,C
  24.             sequenceLock.getConditionA().signal();
  25.         } catch (Exception ex) {
  26.             //TODO
  27.         } finally {
  28.             sequenceLock.getLock().unlock();
  29.         }
  30.         System.exit(0);
  31.     }
  32.  
  33.     @Data
  34.     static class SequenceLock {
  35.         private ReentrantLock lock = new ReentrantLock();
  36.         private Condition conditionA = lock.newCondition();
  37.         private Condition conditionB = lock.newCondition();
  38.         private Condition conditionC = lock.newCondition();
  39.  
  40.         public void a() {
  41.             lock.lock();
  42.             try {
  43.                 log.info("A,wait signal");
  44.                 // wait()的执行前提是当前线程获取了对象控制权,否则会报错:java.lang.IllegalMonitorStateException
  45.                 conditionA.await();
  46.                 log.info("A");
  47.                 // 同 notify()一样,并不会立马释放锁,等程序全部执行完,直到 unlock
  48.                 conditionB.signal();
  49.             } catch (Exception e) {
  50.                 e.printStackTrace();
  51.             } finally {
  52.                 lock.unlock();
  53.             }
  54.         }
  55.  
  56.         public void b() {
  57.             lock.lock();
  58.             try {
  59.                 log.info("B,wait signal");
  60.                 conditionB.await();
  61.                 log.info("B");
  62.                 conditionC.signal();
  63.             } catch (Exception e) {
  64.                 e.printStackTrace();
  65.             } finally {
  66.                 lock.unlock();
  67.             }
  68.         }
  69.  
  70.         public void c() {
  71.         lock.lock();
  72.             try {
  73.                 log.info("C,wait signal");
  74.                 conditionC.await();
  75.                 log.info("C");
  76.             } catch (Exception e) {
  77.                 e.printStackTrace();
  78.             } finally {
  79.                 lock.unlock();
  80.             }
  81.         }
  82.     }
  83. }

执行结果：

A,wait signalB,wait signalC,wait signalABC

5.CountDownLatch(减数器)/ CyclicBarrier(栅栏)

利用CountDownLatch、CyclicBarrier 当成信号变量，作顺序开关。这里只写CountDownLatch代码，CyclicBarrier是类似的。注意：这里需要两个信号通知，因此需要定义两个CountDownLatch。

代码如下：

  1. @Slf4j
  2. public class Test {
  3.  
  4.     /**
  5.      * CountDownLatch(减数器)实现/ CyclicBarrier(栅栏)实现
  6.      * {@link CountDownLatch}
  7.      * {@link CyclicBarrier}
  8.      */
  9.     public static void main(String[] args) {
  10.         // 3个线程需要2两个信号通知,A->B需要一个,B->C需要一个
  11.         CountDownLatch signalAB = new CountDownLatch(1);
  12.         CountDownLatch signalBC = new CountDownLatch(1);
  13.  
  14.         A a = new A(signalAB);
  15.         B b = new B(signalAB,signalBC);
  16.         C c = new C(signalBC);
  17.  
  18.         // 线程池中 按顺序执行 A->B->C
  19.         ExecutorService executorService = Executors.newFixedThreadPool(10);
  20.         executorService.execute(b);
  21.         executorService.execute(c);
  22.         executorService.execute(a);
  23.  
  24.         // 停止接受新任务,当已有任务将执行完,关闭线程池
  25.         executorService.shutdown();
  26.         while (!executorService.isTerminated()) {
  27.             // 等待所有线程执行完成
  28.         }
  29.         System.out.println("over");
  30.         System.exit(0);
  31.  
  32.     }
  33.  
  34.     @AllArgsConstructor
  35.     static class A implements Runnable {
  36.         private CountDownLatch latchAB;
  37.  
  38.         @SneakyThrows
  39.         @Override
  40.         public void run() {
  41.             log.info("A");
  42.             latchAB.countDown();
  43.         }
  44.     }
  45.     @AllArgsConstructor
  46.     static class B implements Runnable {
  47.         private CountDownLatch latchAB;
  48.         private CountDownLatch latchBC;
  49.  
  50.         @SneakyThrows
  51.         @Override
  52.         public void run() {
  53.             latchAB.await();
  54.             log.info("B");
  55.             latchBC.countDown();
  56.         }
  57.     }
  58.  
  59.     @AllArgsConstructor
  60.     static class C implements Runnable {
  61.         private CountDownLatch latchBC;
  62.  
  63.         @SneakyThrows
  64.         @Override
  65.         public void run() {
  66.             latchBC.await();
  67.             log.info("C");
  68.         }
  69.     }
  70. }

执行结果：

A->B->C

6.Semaphore(信号量)

其实跟CountDownLatch 一样，都是作为信号量来传递。同样定义两个信号量。执行结果仍然是A->B->C。

代码如下：

  1. @Slf4j
  2. public class Test {
  3.  
  4.     /**
  5.      * Semaphore 信号量实现
  6.      * {@link Semaphore}
  7.      */
  8.     public static void main(String[] args) {
  9.         // 3个线程需要2两个信号量,A->B需要一个,B->C需要一个
  10.         Semaphore signalAB = new Semaphore(0);
  11.         Semaphore signalBC = new Semaphore(0);
  12.  
  13.         A a = new A(signalAB);
  14.         B b = new B(signalAB, signalBC);
  15.         C c = new C(signalBC);
  16.  
  17.         // 线程池中 按顺序执行 A->B->C
  18.         ExecutorService executorService = Executors.newFixedThreadPool(10);
  19.         executorService.execute(b);
  20.         executorService.execute(c);
  21.         executorService.execute(a);
  22.  
  23.         // 停止接受新任务,当已有任务将执行完,关闭线程池
  24.         executorService.shutdown();
  25.         while (!executorService.isTerminated()) {
  26.             // 等待所有线程执行完成
  27.         }
  28.         System.out.println("over");
  29.         System.exit(0);
  30.  
  31.     }
  32.  
  33.     @AllArgsConstructor
  34.     static class A implements Runnable {
  35.         private Semaphore semaphoreAB;
  36.  
  37.         @SneakyThrows
  38.         @Override
  39.         public void run() {
  40.             log.info("A");
  41.             semaphoreAB.release();
  42.         }
  43.     }
  44.  
  45.     @AllArgsConstructor
  46.     static class B implements Runnable {
  47.         private Semaphore semaphoreAB;
  48.         private Semaphore semaphoreBC;
  49.  
  50.         @SneakyThrows
  51.         @Override
  52.         public void run() {
  53.             // semaphore 信号量-1,总数为0的时候会等待
  54.             semaphoreAB.acquire();
  55.             log.info("B");
  56.             // semaphore 信号量+1
  57.             semaphoreBC.release();
  58.         }
  59.     }
  60.  
  61.     @AllArgsConstructor
  62.     static class C implements Runnable {
  63.         private Semaphore semaphoreBC;
  64.  
  65.         @SneakyThrows
  66.         @Override
  67.         public void run() {
  68.             semaphoreBC.acquire();
  69.             log.info("C");
  70.         }
  71.     }
  72. }

7.FutureTask

通过FutureTask的阻塞特性直接实现线程的顺序执行，这种方式比较简单，有点类似于单线程池执行。执行结果仍然是A->B->C。

代码如下：

  1. @Slf4j
  2. public class ThreadABC {
  3.     /**
  4.      * FutureTask 阻塞特性实现
  5.      */
  6.     public static void main(String[] args) throws ExecutionException, InterruptedException {
  7.         ExecutorService executorService = Executors.newFixedThreadPool(3);
  8.  
  9.         // 实际上 ExecutorService.submit 还是用的 FutureTask
  10.         Object a = executorService.submit(new Runnable() {
  11.             @SneakyThrows
  12.             @Override
  13.             public void run() {
  14.                 log.info("A");
  15.             }
  16.         }).get();
  17.  
  18.         Object b = executorService.submit(new Runnable() {
  19.             @SneakyThrows
  20.             @Override
  21.             public void run() {
  22.                 log.info("B");
  23.             }
  24.         }).get();
  25.  
  26.         Object c = executorService.submit(new Runnable() {
  27.             @SneakyThrows
  28.             @Override
  29.             public void run() {
  30.                 log.info("C");
  31.             }
  32.         }).get();
  33.  
  34.         log.info("main thread done.");
  35.  
  36.         System.exit(0);
  37.     }
  38. }

8.CompletableFuture (推荐)

JDK1.8中 CompletableFuture提供了非常强大的Future的扩展功能，简化异步编程。提供函数式编程的能力，可帮助我们完成复杂的线程的阶段行编程(CompletionStage)。具体这里不详细介绍，不了解的朋友可以去网上查一下资料。

执行代码：

  1. @Slf4j
  2. public class ThreadABC {
  3.  
  4.     /**
  5.      * CompletableFuture (推荐)
  6.      * JDK1.8中 CompletableFuture提供了非常强大的Future的扩展功能，简化异步编程，
  7.      * 提供函数式编程的能力，可帮助我们完成复杂的线程的阶段行编程(CompletionStage)
  8.      * {@link java.util.concurrent.CompletableFuture}
  9.      */
  10.     public static void main(String[] args) throws InterruptedException {
  11.         ExecutorService executorService = Executors.newFixedThreadPool(3);
  12.  
  13.         // 有a,b,c三个线程(任务)
  14.         Runnable a = () -> log.info("A");
  15.         Runnable b = () -> log.info("B");
  16.         Runnable c = () -> log.info("C");
  17.  
  18.         // 异步执行
  19.         CompletableFuture.runAsync(a, executorService).thenRun(b).thenRun(c);
  20.  
  21.         log.info("main thread.");
  22.         // 停止接受新任务,当已有任务将执行完,关闭线程池
  23.         executorService.shutdown();
  24.         while (!executorService.isTerminated()) {
  25.             // 等待所有线程执行完成
  26.         }
  27.         System.exit(0);
  28.     }
  29. }

执行结果：

main thread.ABC

多线程的执行顺序，在面试过程中经常会被问到。不了解的，可以收藏一下。笔者建议不了解CompletableFuture，可以去尝试写一些例子。功能真的很强大！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/197797
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号