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

置顶 已于 2022-10-15 10:36:51 修改
阅读量8.5k 收藏 58
点赞数 11
分类专栏： # java 文章标签： java 多线程
于 2021-08-20 15:53:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/q258523454/article/details/117998310
版权

版权声明：本文为博主原创文章，遵循 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

@Slf4j
public class MyRunnable implements Runnable {

    /**
     * 自定义线程名
     */
    private String threadName;

    /**
     * CountDownLatch指令
     */
    private CountDownLatch latch;

    public MyRunnable(String threadName, CountDownLatch latch) {
        this.threadName = threadName;
        this.latch = latch;
    }

    @Override
    public void run()
    {
        try {
            // 等待 countDownLatch.countDown() 命名
            latch.await();
            System.out.println(threadName);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

创建单个线程池

/**
 * 利用单线程池达到顺序执行
 * {@link java.util.concurrent.LinkedBlockingQueue} 保证了FIFO顺序
 */
public static void main(String[] args) {
    ExecutorService executorService = Executors.newFixedThreadPool(1);
    // CountDownLatch减数机制,countDown触发await,达到同时执行的目的
    CountDownLatch latch = new CountDownLatch(1);

    List<String> threadNameList = Arrays.asList("A", "B", "C");
    for (int i = 0; i < 3; i++) {
        executorService.execute(new MyRunnable(threadNameList.get(i), latch));
    }

    latch.countDown();
    executorService.shutdown();
    while (!executorService.isTerminated()) {
        // 等待所有线程执行完成
    }
    System.exit(0);
}

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

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

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

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

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

执行代码：

@Slf4j
public class Test {

    /**
     * 使用 object.wait()/object.notify()
     */
    @SneakyThrows
    public static void main(String[] args) {
        final Object pv = new Object();

        ThreadB b = new ThreadB();
        ThreadA a = new ThreadA(b);

        // 期望顺序 A->B
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        // 这里必须要让B先执行才能正常执行,否则会让B一直处于wait()
        // 原因: 如果A先拿到对象锁,执行notify()无法唤醒B, 因为B还没有拿到对象锁,还没有执行wait()
        // 因此: 同一个锁的执行顺序一定是 wait()-notify()
        executorService.execute(b);
        Thread.sleep(100);
        executorService.execute(a);


        // 停止接受新任务,当已有任务将执行完,关闭线程池
        executorService.shutdown();
        while (!executorService.isTerminated()) {
            // 等待所有线程执行完成
        }
        System.exit(0);
    }

    static class ThreadB implements Runnable {
        @Override
        public void run() {
            synchronized (this) {
                try {
                    log.info("B线程等待A线程 doing");
                    // wait()的执行前提是当前线程获取了对象控制权,否则会报错:java.lang.IllegalMonitorStateException
                    this.wait();
                    log.info("B线程等待A线程 done");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                log.info("B线程执行完成.");
            }
        }
    }

    @AllArgsConstructor
    static class ThreadA implements Runnable {
        private final Object obj;

        @SneakyThrows
        @Override
        public void run() {
            synchronized (obj) {
                // notify()不会立马释放对象锁,释放情景: 1.synchronized代码块执行完成; 2.主动释放 wait();
                obj.notify();
                log.info("A线程开始执行.");
                log.info("A线程执行完成.");
            }
        }
    }
}

 执行结果:

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

4.ReentrantLock-Condition(重入锁)

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

实现代码：

@Slf4j
public class Test {

    /**
     * 重入锁实现(ReentrantLock-Condition)
     */
    @SneakyThrows
    public static void main(String[] args) {

        ExecutorService executorService = Executors.newFixedThreadPool(3);

        final SequenceLock sequenceLock = new SequenceLock();
        Runnable a = () -> sequenceLock.a();
        Runnable b = () -> sequenceLock.b();
        Runnable c = () -> sequenceLock.c();
        executorService.execute(a);
        executorService.execute(b);
        executorService.execute(c);

        Thread.sleep(1000);
        sequenceLock.getLock().lock();
        try {
            // 唤醒A线程,依次执行A,B,C
            sequenceLock.getConditionA().signal();
        } catch (Exception ex) {
            //TODO
        } finally {
            sequenceLock.getLock().unlock();
        }
        System.exit(0);
    }

    @Data
    static class SequenceLock {
        private ReentrantLock lock = new ReentrantLock();
        private Condition conditionA = lock.newCondition();
        private Condition conditionB = lock.newCondition();
        private Condition conditionC = lock.newCondition();

        public void a() {
            lock.lock();
            try {
                log.info("A,wait signal");
                // wait()的执行前提是当前线程获取了对象控制权,否则会报错:java.lang.IllegalMonitorStateException
                conditionA.await();
                log.info("A");
                // 同 notify()一样,并不会立马释放锁,等程序全部执行完,直到 unlock
                conditionB.signal();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }

        public void b() {
            lock.lock();
            try {
                log.info("B,wait signal");
                conditionB.await();
                log.info("B");
                conditionC.signal();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }

        public void c() {
        lock.lock();
            try {
                log.info("C,wait signal");
                conditionC.await();
                log.info("C");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }
}

执行结果：

A,wait signalB,wait signalC,wait signalABC

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

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

代码如下：

@Slf4j
public class Test {

    /**
     * CountDownLatch(减数器)实现/ CyclicBarrier(栅栏)实现
     * {@link CountDownLatch}
     * {@link CyclicBarrier}
     */
    public static void main(String[] args) {
        // 3个线程需要2两个信号通知,A->B需要一个,B->C需要一个
        CountDownLatch signalAB = new CountDownLatch(1);
        CountDownLatch signalBC = new CountDownLatch(1);

        A a = new A(signalAB);
        B b = new B(signalAB,signalBC);
        C c = new C(signalBC);

        // 线程池中 按顺序执行 A->B->C
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        executorService.execute(b);
        executorService.execute(c);
        executorService.execute(a);

        // 停止接受新任务,当已有任务将执行完,关闭线程池
        executorService.shutdown();
        while (!executorService.isTerminated()) {
            // 等待所有线程执行完成
        }
        System.out.println("over");
        System.exit(0);

    }

    @AllArgsConstructor
    static class A implements Runnable {
        private CountDownLatch latchAB;

        @SneakyThrows
        @Override
        public void run() {
            log.info("A");
            latchAB.countDown();
        }
    }
    @AllArgsConstructor
    static class B implements Runnable {
        private CountDownLatch latchAB;
        private CountDownLatch latchBC;

        @SneakyThrows
        @Override
        public void run() {
            latchAB.await();
            log.info("B");
            latchBC.countDown();
        }
    }

    @AllArgsConstructor
    static class C implements Runnable {
        private CountDownLatch latchBC;

        @SneakyThrows
        @Override
        public void run() {
            latchBC.await();
            log.info("C");
        }
    }
}

执行结果：

A->B->C

6.Semaphore(信号量)

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

代码如下：

@Slf4j
public class Test {

    /**
     * Semaphore 信号量实现
     * {@link Semaphore}
     */
    public static void main(String[] args) {
        // 3个线程需要2两个信号量,A->B需要一个,B->C需要一个
        Semaphore signalAB = new Semaphore(0);
        Semaphore signalBC = new Semaphore(0);

        A a = new A(signalAB);
        B b = new B(signalAB, signalBC);
        C c = new C(signalBC);

        // 线程池中 按顺序执行 A->B->C
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        executorService.execute(b);
        executorService.execute(c);
        executorService.execute(a);

        // 停止接受新任务,当已有任务将执行完,关闭线程池
        executorService.shutdown();
        while (!executorService.isTerminated()) {
            // 等待所有线程执行完成
        }
        System.out.println("over");
        System.exit(0);

    }

    @AllArgsConstructor
    static class A implements Runnable {
        private Semaphore semaphoreAB;

        @SneakyThrows
        @Override
        public void run() {
            log.info("A");
            semaphoreAB.release();
        }
    }

    @AllArgsConstructor
    static class B implements Runnable {
        private Semaphore semaphoreAB;
        private Semaphore semaphoreBC;

        @SneakyThrows
        @Override
        public void run() {
            // semaphore 信号量-1,总数为0的时候会等待
            semaphoreAB.acquire();
            log.info("B");
            // semaphore 信号量+1
            semaphoreBC.release();
        }
    }

    @AllArgsConstructor
    static class C implements Runnable {
        private Semaphore semaphoreBC;

        @SneakyThrows
        @Override
        public void run() {
            semaphoreBC.acquire();
            log.info("C");
        }
    }
}

7.FutureTask

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

代码如下：

@Slf4j
public class ThreadABC {
    /**
     * FutureTask 阻塞特性实现
     */
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(3);

        // 实际上 ExecutorService.submit 还是用的 FutureTask
        Object a = executorService.submit(new Runnable() {
            @SneakyThrows
            @Override
            public void run() {
                log.info("A");
            }
        }).get();

        Object b = executorService.submit(new Runnable() {
            @SneakyThrows
            @Override
            public void run() {
                log.info("B");
            }
        }).get();

        Object c = executorService.submit(new Runnable() {
            @SneakyThrows
            @Override
            public void run() {
                log.info("C");
            }
        }).get();

        log.info("main thread done.");

        System.exit(0);
    }
}

8.CompletableFuture (推荐)

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

执行代码：

@Slf4j
public class ThreadABC {

    /**
     * CompletableFuture (推荐)
     * JDK1.8中 CompletableFuture提供了非常强大的Future的扩展功能，简化异步编程，
     * 提供函数式编程的能力，可帮助我们完成复杂的线程的阶段行编程(CompletionStage)
     * {@link java.util.concurrent.CompletableFuture}
     */
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(3);

        // 有a,b,c三个线程(任务)
        Runnable a = () -> log.info("A");
        Runnable b = () -> log.info("B");
        Runnable c = () -> log.info("C");

        // 异步执行
        CompletableFuture.runAsync(a, executorService).thenRun(b).thenRun(c);

        log.info("main thread.");
        // 停止接受新任务,当已有任务将执行完,关闭线程池
        executorService.shutdown();
        while (!executorService.isTerminated()) {
            // 等待所有线程执行完成
        }
        System.exit(0);
    }
}

执行结果：

main thread.ABC

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

Mr.Java.
关注
  • 11
    点赞
  • 踩
  • 58
    收藏
    觉得还不错? 一键收藏
  • 9
    评论
专栏目录
让线程按顺序执行8种方法.doc
10-05
让线程按顺序执行8种方法.doc
Java 多线程有序执行的几种方法总结
08-31
在方法一中，我们使用了 AtomicInteger 来控制线程的执行顺序。AtomicInteger 是 Java 中的一个原子变量类，提供了原子性的操作。我们可以使用 AtomicInteger 的 incrementAndGet() 方法来递增计数器，并使用 get() ...
面试官：线程顺序执行,这么多答案你都答不上来？
欢迎关注公众号：【码农突围】，公号后台回复9999，可以获取一份500页的LeetCode刷题笔记。
02-26 468
点击上方“码农突围”，马上关注 这里是码农充电第一站，回复“666”，获取一份专属大礼包 真爱，请设置“星标”或点个“在看” 来源：https://cnblogs.com/wenjunw...
java三个线程如何做到顺序执行
最新发布
weixin_39304656的博客
06-11 425
在 Java 中，要控制三个线程的执行顺序，可以使用多种方法，其中包括使用wait和notify机制，，以及Semaphore等。下面我将展示这些方法的具体实现。
让线程顺序运行的11种方法
lyf_zm的博客
04-11 5241
一、让线程顺序运行的11种方法 1 方法说明 使用线程的join方法 使用主线程的join方法 使用线程的wait方法 使用线程的线程池方法 使用线程的Condition（条件变量）方法 使用CountDownLatch（倒计数）的方法 使用线程的CyclicBarrier（回环栅栏）方法 使用线程的Semaphore（信号量）方法 使用LockSupport的park与unpark方法 使用阻塞队列的put与take方法 使用CAS思想来完成多线程的顺序执行AtomicReference<Thre
让线程按顺序执行8种方法
qq_40704861的博客
02-28 4948
转自：https://www.cnblogs.com/wenjunwei/p/10573289.html 一.前言 本文使用了7中方法实现在多线程中让线程按顺序运行的方法，涉及到多线程中许多常用的方法，不止为了知道如何让线程按顺序运行，更是让读者对多线程的使用有更深刻的了解。 使用的方法如下: [1] 使用线程的join方法 [2] 使用主线程的join方法 [3] 使用线程的wait方法 [4] 使用线程的线程池方法 [5] 使用线程的Condition(条件变量)方法 [6] 使用线程的CountDow
如何确保三个线程顺序执行？
sushuiyuzhou的专栏
05-17 3538
场景：有三个线程t1、t2、t3。确保三个线程t1执行完后t2执行，t2执行完成后t3执行。 1.使用join thread.Join把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。比如在线程B中调用了线程A的Join()方法，直到线程A执行完毕后，才会继续执行线程B。 t.join(); //调用join方法，等待线程t执行完毕 t.join(1000); //等待 t 线程，等待时间是1000毫秒。 public class ThreadTest1...
java多线程按顺序执行的7种方式
lyd的博客
04-30 3122
java多线程按顺序执行的7种方式
Java实现指定线程执行顺序的三种方式示例
08-26
在上面的代码中，我们使用了三个线程ThreadAA、ThreadBB和ThreadCC，每个线程执行一个不同的方法methodA()、methodB()和methodC()。我们使用了共享对象锁和volatile关键字来确保线程按照一定的顺序执行。在main()...
C# 不使用Task实现的多线程顺序执行
06-19
在某些特殊情况下需要用到多线程然而又要使其具备顺序性，这种时候就有了一个特殊的场景那就是多线程顺序执行，在现在VS2015中Task自带了顺序执行的方法，但在此之前的旧项目中如果需要使用多线程顺序执行该怎么办呢...
改变 Python 中线程执行顺序的方法
09-24
守护线程是一种特殊类型的线程，当程序中的主线程和其他非守护线程执行完毕后，即使守护线程尚未完成，程序也会结束。要创建一个守护线程，只需将线程对象的`daemon`属性设置为`True`，如下所示： ```python import...
Java多线程按指定顺序同步执行
08-25
Java多线程按指定顺序同步执行是Java编程中的一种常见问题，即如何让多个线程按照既定的顺序依次执行。下面将介绍三种解决方案，分别使用newSingleThreadExecutor、join方法和ThreadPoolExecutor。 方法1：使用...
iOS中的多线程如何按设定顺序去执行任务详解
08-28
GCD提供了一种称为`dispatch_barrier_async`的方法，用于在一组并发任务执行完后，执行一个屏障任务，然后继续执行后续的并发任务。然而，要注意的是，`dispatch_barrier_async`要求传入的队列是由`dispatch_queue_...
在IOS中为什么使用多线程及多线程实现的三种方法
09-03
此外，NSOperation之间还可以建立依赖关系，确保操作按正确的顺序执行。 **四、Grand Central Dispatch (GCD)** GCD是Apple在macOS 10.6和iOS 4.0之后引入的低级并发工具，它基于C语言，但与Objective-C和Swift...
一种将顺序程序划分为多个推测线程的以数据结构为中心的方法和执行模型
03-10
一种将顺序程序划分为多个推测线程的以数据结构为中心的方法和执行模型
java向多线程中传递参数的三种方法详细介绍
09-05
在Java编程中，多线程环境下的数据传递与同步开发模式下的方式有所不同，因为线程的执行顺序和结束时间是不确定的，无法像普通函数那样直接通过参数和返回值进行数据交互。以下将详细介绍三种向Java多线程传递参数的...
java 多线程按顺序执行、顺序获取结果
T-bright的博客
12-10 4751
文章目录1、通过Thread的join方法2、FutureTask3、CountDownLatch（倒计数）4、wait、notify5、Condition(条件变量)6、CyclicBarrier(回环栅栏)5、线程池5.1、单线程化线程池5.2、多线程化线程池 1、通过Thread的join方法 join主要是让父线程等待子线程结束之后父线程才能继续运行 public static void main(String[] args) throws InterruptedException {
线程的执行顺序
一个菜鸟的博客
09-01 1649
调用线程的wait()方法时,会使主线程处于等待状态,等待子线程执行完成后再次向下执行.也就是说,再ThreadSort类的main()方法中,调用thread1的join()方法,会阻塞main()方法的执行,当thread1执行完成后,main()方法继续向下执行.启动thread2,调用thread2.join()方法…以此类推,确保线程按照线程的启动顺序来执行。
ABC三个线程顺序执行（简单实现）
Crayon的博客
06-29 9995
需求：3个线程 输出ABC ------> ABCABCABC。。。。。此类型 1、 使用线程池将所有线程放入一个队列 ，保证顺序输出 public class ThreeThread { public static void main(String[] args) throws InterruptedException { //用线程池来实...
多线程为什么要加锁? 列举线程通信的几种方法 ?
05-16
多线程中要加锁是为了保证线程安全，避免多个线程同时访问共享资源，导致数据不一致或者其他问题。如果不加锁，就可能会导致数据竞争，从而导致程序崩溃或者运行结果不正确。 线程通信的几种方法有： 1. 临界区：通过加锁的方式保证同一时间只有一个线程能够访问共享资源，其他线程需要等待锁的释放才能访问。 2. 信号量：通过信号量来控制线程的执行顺序，比如一个线程完成了某个任务后会释放一个信号量，另一个线程等待这个信号量的释放才能继续执行。 3. 条件变量：可以让线程在特定条件下等待或者唤醒，比如一个线程等待某个共享资源的状态改变，另一个线程修改了这个共享资源的状态后会通过条件变量唤醒等待的线程。 4. 管道：用于进程间通信，可以实现在不同进程之间传递数据。 5. 共享内存：多个进程可以访问同一块内存区域，实现数据共享。 6. 消息队列：进程之间通过消息队列通信，可以实现进程间异步通信。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值