java并发-如何保证线程按照顺序执行？

已于 2024-06-09 22:48:16 修改
阅读量394 收藏 4
点赞数 9
分类专栏： java并发编程实战 文章标签： java
于 2024-06-09 22:45:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/PacosonSWJTU/article/details/139551964
版权

【readme】

  1. 使用只有单个线程的线程池（最简单）
  2. Thread.join() 
  3. 可重入锁 ReentrantLock + Condition 条件变量（多个） ； 原理如下：
    1. 任务1执行前在锁1上阻塞；执行完成后在锁2上唤醒；
    2. 任务2执行前在锁2上阻塞，执行完成后在锁3上唤醒；
    3. 任务n执行前在锁n上阻塞，执行完成后在锁n+1上唤醒；
    4. 以此类推 ..............
    5. 补充：
      1. 第1条任务执行前可以不阻塞，但执行完成后必须唤醒；（如果要阻塞，则可以让主线程来唤醒第1条任务）；
      2. 补充： 最后一条任务执行后可以不唤醒，但执行前必须阻塞； （如果要唤醒，则最后一条任务执行完成后唤醒主线程）；
  4. 与可重入锁类似，可以使用monitor监视器锁（多个）；
  5. 与可重入锁类似，使用 Semaphore 信号量（多个）；
  6. 与可重入锁类似，CountDownLatch ： 倒计时锁存器（多个）； 
  7. 与可重入锁类似，CyclicBarrier 循环栅栏（多个） ；

【1】单个线程的线程池

参数设置：核心线程数=1， 最大线程数=1，就能保证线程池中只有1个线程在运行；

public class OrderlySingleThreadPoolTest {
    public static void main(String[] args) {
        ThreadPoolExecutor singleThreadPool =
                new ThreadPoolExecutor(1, 1, 0, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(100));
        singleThreadPool.execute(new Task(1));
        singleThreadPool.execute(new Task(2));
        singleThreadPool.execute(new Task(3));
        singleThreadPool.execute(new Task(4));
        singleThreadPool.execute(new Task(5));
        singleThreadPool.shutdown();
    }

    private static class Task implements Runnable {
        int order; // 执行序号

        Task(int order) {
            this.order = order;
        }

        @Override
        public void run() {
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            PrintUtils.print("序号=" + order + "执行完成");
        }
    }
}

【打印结果】

2024-06-09 16:07:59.398 序号=1执行完成
2024-06-09 16:08:02.404 序号=2执行完成
2024-06-09 16:08:05.411 序号=3执行完成
2024-06-09 16:08:08.425 序号=4执行完成
2024-06-09 16:08:11.439 序号=5执行完成

【2】thread.join()

main 调用 t1.join()，则main线程阻塞直到t1线程执行完成；如下。

public class ThreadJoinTest {
    public static void main(String[] args) {
        f1();
        PrintUtils.print("主线程结束");
    }

    public static void f1() {
        Thread t1 = new Thread(()->{
            try {
                TimeUnit.SECONDS.sleep(5);
                PrintUtils.print("t1线程结束");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        t1.start();
        try {
            t1.join();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}
2024-06-09 07:44:38.474 t1线程结束
2024-06-09 07:44:38.573 主线程结束

【3】可重入锁+条件变量实现多个线程顺序执行

1. 补充：

condition.await() 调用前需要获取锁；调用后释放锁（其他线程可以获取该锁，因此得名为可重入），但当前线程阻塞；

condition.signal() 调用前需要获取锁；调用后释放锁；

public class OrderlyReentrantLockTest {
    private static Condition[][] build(ReentrantLock reentrantLock, int num) {
        Condition[][] arr = new Condition[num][2];
        arr[0] = new Condition[]{null, reentrantLock.newCondition()};
        int i = 1;
        for (; i < num - 1; i++) {
            arr[i] = new Condition[]{arr[i - 1][1], reentrantLock.newCondition()};
        }
        arr[i] = new Condition[]{arr[i - 1][1], null};
        return arr;
    }

    public static void main(String[] args) {
        int threadNum = 5;
        ThreadPoolExecutor threadPool =
                new ThreadPoolExecutor(threadNum, threadNum, 0, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(100));
        ReentrantLock reentrantLock = new ReentrantLock(true);
        AtomicInteger unWaitNum = new AtomicInteger(threadNum);

        // 构建条件变量数组
        Condition[][] conditionTwoArr = build(reentrantLock, threadNum);
        // 提交任务
        for (int order = threadNum; order >= 1; order--) {
            OrderlyTask orderlyTask = new OrderlyTask(reentrantLock, conditionTwoArr[order - 1], order, unWaitNum);
            threadPool.execute(orderlyTask);
            // 阻塞成功，才提交下一个任务
            while (unWaitNum.get() == threadNum) ; // 这里可能死循环，但可以新增超时重试机制来处理
            PrintUtils.print("阻塞成功，线程order=" + order);
        } 
        threadPool.shutdown();
    }

    private static class OrderlyTask implements Runnable {
        private ReentrantLock lock;
        private Condition[] conditions;
        private int order; // 执行序号
        private AtomicInteger unWaitNum;

        OrderlyTask(ReentrantLock reentrantLock, Condition[] conditions, int order, AtomicInteger unWaitNum) {
            this.lock = reentrantLock;
            this.conditions = conditions;
            this.order = order;
            this.unWaitNum = unWaitNum;
        }

        @Override
        public void run() {
            lock.lock();
            try {
                unWaitNum.decrementAndGet();
                try {
                    if (conditions[0] != null) {
                        conditions[0].await(); // 在第1个条件变量上阻塞
                    }
                } catch (Exception e) {
                    unWaitNum.incrementAndGet();
                    throw e;
                }
                // 处理业务逻辑
                TimeUnit.SECONDS.sleep(3);
                // 唤醒在第2个条件变量上阻塞的线程
                if (conditions[1] != null) {
                    conditions[1].signal();
                }
            } catch (Exception e) {
                System.err.println(e);
            } finally {
                lock.unlock();
            }
            PrintUtils.print("执行完成， 线程order=" + order + ", 线程id=" + Thread.currentThread().getName());
        }
    }
}

打印结果：

2024-06-09 22:16:00.696 阻塞成功，线程order=5
2024-06-09 22:16:00.698 阻塞成功，线程order=4
2024-06-09 22:16:00.698 阻塞成功，线程order=3
2024-06-09 22:16:00.698 阻塞成功，线程order=2
2024-06-09 22:16:00.698 阻塞成功，线程order=1
2024-06-09 22:16:03.707 执行完成， 线程order=1, 线程id=pool-1-thread-5
2024-06-09 22:16:06.719 执行完成， 线程order=2, 线程id=pool-1-thread-4
2024-06-09 22:16:09.719 执行完成， 线程order=3, 线程id=pool-1-thread-3
2024-06-09 22:16:12.727 执行完成， 线程order=4, 线程id=pool-1-thread-2
2024-06-09 22:16:15.729 执行完成， 线程order=5, 线程id=pool-1-thread-1

【4】使用CountDownLatch倒计时锁存器 

public class OrderlyCountDownLatchTest {

    private static CountDownLatch[][] build(int num) {
        CountDownLatch[][] arr = new CountDownLatch[num][2];
        arr[0] = new CountDownLatch[]{null, new CountDownLatch(1)};
        int i = 1;
        for (; i < num - 1; i++) {
            arr[i] = new CountDownLatch[]{arr[i - 1][1], new CountDownLatch(1)};
        }
        arr[i] = new CountDownLatch[]{arr[i - 1][1], null};
        return arr;
    }

    public static void main(String[] args) {
        int threadNum = 5;
        ThreadPoolExecutor threadPool =
                new ThreadPoolExecutor(threadNum, threadNum, 0, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(100));
        AtomicInteger unWaitNum = new AtomicInteger(threadNum);

        // 构建倒计时锁存器数组
        CountDownLatch[][] latchArr = build(threadNum);
        // 提交任务
        for (int order = threadNum; order >= 1; order--) {
            OrderlyTask orderlyTask = new OrderlyTask(latchArr[order - 1], order, unWaitNum);
            threadPool.execute(orderlyTask);
            // 阻塞成功，才提交下一个任务
            while (unWaitNum.get() == threadNum) ; // 这里可能死循环，但可以新增超时重试机制来处理
            PrintUtils.print("阻塞成功，线程order=" + order);
        }
        threadPool.shutdown();
    }

    private static class OrderlyTask implements Runnable {
        private CountDownLatch[] latchArr;
        private int order; // 执行序号
        private AtomicInteger unWaitNum;

        OrderlyTask(CountDownLatch[] latchArr, int order, AtomicInteger unWaitNum) {
            this.latchArr = latchArr;
            this.order = order;
            this.unWaitNum = unWaitNum;
        }

        @Override
        public void run() {
            try {
                unWaitNum.decrementAndGet();
                try {
                    if (latchArr[0] != null) {
                        latchArr[0].await(); // 在第1个锁存器上阻塞
                    }
                } catch (Exception e) {
                    unWaitNum.incrementAndGet();
                    throw e;
                }
                // 处理业务逻辑
                TimeUnit.SECONDS.sleep(3);
                // 唤醒在第2个条件变量上阻塞的线程
                if (latchArr[1] != null) {
                    latchArr[1].countDown();
                }
            } catch (Exception e) {
                System.err.println(e);
            }
            PrintUtils.print("执行完成， 线程order=" + order + ", 线程id=" + Thread.currentThread().getName());
        }
    }
}

打印结果： 
 

2024-06-09 22:35:13.648 阻塞成功，线程order=5
2024-06-09 22:35:13.651 阻塞成功，线程order=4
2024-06-09 22:35:13.651 阻塞成功，线程order=3
2024-06-09 22:35:13.651 阻塞成功，线程order=2
2024-06-09 22:35:13.651 阻塞成功，线程order=1
2024-06-09 22:35:16.664 执行完成， 线程order=1, 线程id=pool-1-thread-5
2024-06-09 22:35:19.676 执行完成， 线程order=2, 线程id=pool-1-thread-4
2024-06-09 22:35:22.682 执行完成， 线程order=3, 线程id=pool-1-thread-3
2024-06-09 22:35:25.684 执行完成， 线程order=4, 线程id=pool-1-thread-2
2024-06-09 22:35:28.688 执行完成， 线程order=5, 线程id=pool-1-thread-1

tomjourney
关注
  • 9
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
教你如何轻松实现三个线程的有序执行！
**My Coding Family**
05-30 1047
如何保证三个线程按顺序执行？不会我教你
JAVA线程高级-线程按序交替执行
11-01
java多线程按需交替执行，java新特性。
让线程按顺序执行8种方法
Java笔记虾
09-01 1742
作者：俊俊的小熊饼干 cnblogs.com/wenjunwei/p/10573289.html 一.前言 本文使用了8种方法实现在多线程中让线程按顺序运行的方法，涉及到多线程中许多常用的方法，不止为了知道如何让线程按顺序运行，更是让读者对多线程的使用有更深刻的了解。使用的方法如下: [1] 使用线程的join方法 [2] 使用主线程的join方法 [3] 使用线程的wait方法 [...
Java中如何保证线程顺序执行
猿码天地
05-19 1985
我是猿人，一个热爱技术、热爱编程的IT猿。技术是开源的，知识是共享的！写作是对自己学习的总结和记录，如果您对 Java、分布式、微服务、中间件、Spring Boot、Spring Clo...
让线程顺序运行的11种方法
lyf_zm的博客
04-11 5252
一、让线程顺序运行的11种方法 1 方法说明 使用线程的join方法 使用主线程的join方法 使用线程的wait方法 使用线程的线程池方法 使用线程的Condition（条件变量）方法 使用CountDownLatch（倒计数）的方法 使用线程的CyclicBarrier（回环栅栏）方法 使用线程的Semaphore（信号量）方法 使用LockSupport的park与unpark方法 使用阻塞队列的put与take方法 使用CAS思想来完成多线程的顺序执行AtomicReference<Thre
线程顺序执行的8种方法，最后一种你用过吗？
张小凡
08-20 8559
面试官：3个线程，按顺序先后执行？
java多线程保证顺序执行
大家好，我是云村的王子
09-29 4368
多线程保证顺序执行
保证多线程顺序执行，四种方案，你知道几种？
u011220840的博客
08-03 2167
上周一位同学在面试中遇到了这么一道问题：有三个线程T1、T2、T3，如何保证顺序执行？常规操作，启动三个线程，让其执行。调用三个线程的start方法，很明显是按照顺序调用的，但是每次运行出来的结果，基本上都不相同，随机性特别强。怎么办呢？下面我们使用四种方案来实现。
java10个线程按照顺序打印1-100
12-26
在上述的10个线程顺序打印1-100的问题中，可能的解决方案包括但不限于创建一个共享的计数器，使用`synchronized`和`wait/notify`，或者使用`Semaphore`，`CyclicBarrier`等并发工具。每个解决方案都需要考虑线程安全...
Java并发编程示例(六)：等待线程执行终止
09-04
在Java并发编程中，等待线程执行终止是一个关键的概念，特别是在多线程环境中需要确保某个任务完成后才能继续执行后续操作的场景。本示例（Java并发编程示例六）通过一个具体的程序展示了如何使用`Thread.join()`...
人工智能-项目实践-多线程-Java多线程高并发实例.zip
01-04
在单线程环境中，程序按照顺序执行任务。而在多线程环境中，一个程序可以同时执行多个不同的任务，这极大地提高了计算机的资源利用率和程序的响应速度。在Java中，通过实现`Runnable`接口或继承`Thread`类来创建线程...
Java多线程与并发-原理
12-21
Java多线程与并发是构建高性能、高可用系统的关键技术之一。在Java中，`synchronized`关键字用于实现线程间的同步，确保并发环境下的数据一致性。本文将深入探讨`synchronized`的工作原理、实现机制以及与其他并发...
java如何让线程乱序执行_多线程如何按指定顺序同步执行
weixin_30109877的博客
02-27 674
笔者今天看到一个有趣的面试题，如何让多个线程按照既定的顺序依次执行？比如每个线程输出一个整数，那么期望就是这样的：0，1，2，3，4，5，6，7，8，9.而不是0，2，4，1，3，5，8，7，9，6乍一看，这不是反人性的考题吗？多线程本来就以乱序执行出名的。稍加思索，想到3种解决方案，分别用代码实现之。方法1 使用newSingleThreadExecutornewSingleThreadExec...
如何控制多线程的顺序执行
最新发布
cjaems的博客
03-13 874
9种方法实现多线程的顺序执行，定义thread1、thread2、thread3，要求执行顺序为：thread1 > thread2 > thread3。
如何保证线程的顺序执行的四种方法
迷失在代码的海洋里
06-03 1776
1使用join thread.join();使主线程等待thread执行完毕。 2使用Executors.newSingleThreadExecutor()。
如何让多个线程按顺序执行
NullpointerExcep的博客
10-15 1527
在多线程中有多种方法让线程按特定顺序执行，你可以用线程类的。本质上就变成了“单线程进行执行”。为了确保三个线程的顺序你应该先启动。一个线程中启动另一个线程，
Thread.join()方法
zx_ssln的博客
11-05 1437
转自https://blog.csdn.net/chenkaibsw/article/details/80912878 1.synchronized中的对象锁是线程的实例 我们可以使用同步语句块的方式对需要同步的代码进行包裹。 Object obj = new Object(); synchronized(obj){    obj.wait();    //线程在这里等待 } 此时线程会...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值