java多线程按顺序执行的7种方式

已于 2023-05-27 10:58:49 修改
阅读量3.1k 收藏 9
点赞数 1
文章标签： java
于 2023-04-30 17:07:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43938143/article/details/130448517
版权

3个线程，按顺序打印A,B,C，一共打印100个字符串

准备：定义使用的枚举

/**
 * 符号枚举
 *
 * @author Administrator
 */
public enum SignEnum {
    /**/
    A {
        @Override
        public SignEnum last() {
            return C;
        }
    },
    B {
        @Override
        public SignEnum last() {
            return A;
        }
    },
    C {
        @Override
        public SignEnum last() {
            return B;
        }
    };

    /**
     * 上一个符号
     *
     * @return 符号
     */
    public abstract SignEnum last();
}

有锁操作

使用线程通信

1：Object 的 wait / notifyAll

/**
 * 通过wait/notify打印
 *
 * @author Administrator
 */
public class WaitNotifyTest {

    /**
     * 锁
     */
    private final Object lock = new Object();
    /**
     * 当前符号
     */
    private volatile SignEnum currentSign = SignEnum.C;
    /**
     * 自定义线程池
     */
    private final ThreadPoolExecutor executor = new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors(),
            Runtime.getRuntime().availableProcessors() * 2, 5, TimeUnit.MINUTES,
            new LinkedBlockingQueue<>(3), Thread::new, new ThreadPoolExecutor.AbortPolicy());

    /**
     * 打印
     */
    @Test
    @SneakyThrows
    public void testPrint() {
        // 打印B
        Future<?> bFuture = executor.submit(() -> doPrint(33, SignEnum.B));
        // 打印A
        Future<?> aFuture = executor.submit(() -> doPrint(34, SignEnum.A));
        // 打印C
        Future<?> cFuture = executor.submit(() -> doPrint(33, SignEnum.C));
        // 等待打印完成
        while (!aFuture.isDone() || !bFuture.isDone() || !cFuture.isDone()) {
            TimeUnit.MILLISECONDS.sleep(5);
        }
        // 关闭线程池
        executor.shutdown();
    }

    /**
     * 执行打印
     *
     * @param count      次数
     * @param targetSign 目标符号
     */
    @SneakyThrows
    private void doPrint(int count, SignEnum targetSign) {
        synchronized (lock) {
            for (int index = 0; index < count; index++) {
                // 如果当前符号为目标符号的上一个符号，执行打印符号
                if (Objects.equals(targetSign.last(), currentSign)) {
                    // 打印目标符号
                    System.out.print(targetSign.name());
                    // 打印分割符，方便观察
                    if (Objects.equals(SignEnum.C, targetSign)) {
                        System.out.print("|");
                    }
                    // 切换当前符号
                    currentSign = targetSign;
                    // 释放锁，通知其他线程
                    // 不能使用notify，如果通知的某个线程不符合条件，进行等待，将会造成程序阻塞
                    lock.notifyAll();
                }
                // 不匹配的话，index回退，同时进行等待
                else {
                    index--;
                    lock.wait();
                }
            }
        }
    }
}

输出
在这里插入图片描述

2：Condition 的 await / signalAll

/**
 * 通过condition打印
 *
 * @author Administrator
 */
public class ConditionTest {

    /**
     * 锁
     */
    private final Lock lock = new ReentrantLock();
    /**
     * 条件
     */
    private final Condition condition = lock.newCondition();
    /**
     * 当前符号
     */
    private volatile SignEnum currentSign = SignEnum.C;
    /**
     * 自定义线程池
     */
    private final ThreadPoolExecutor executor = new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors(),
            Runtime.getRuntime().availableProcessors() * 2, 5, TimeUnit.MINUTES,
            new LinkedBlockingQueue<>(3), Thread::new, new ThreadPoolExecutor.AbortPolicy());

    /**
     * 打印
     */
    @Test
    @SneakyThrows
    public void testPrint() {
        // 打印B
        Future<?> bFuture = executor.submit(() -> doPrint(33, SignEnum.B));
        // 打印A
        Future<?> aFuture = executor.submit(() -> doPrint(34, SignEnum.A));
        // 打印C
        Future<?> cFuture = executor.submit(() -> doPrint(33, SignEnum.C));
        // 等待打印完成
        while (!aFuture.isDone() || !bFuture.isDone() || !cFuture.isDone()) {
            TimeUnit.MILLISECONDS.sleep(5);
        }
        // 关闭线程池
        executor.shutdown();
    }

    /**
     * 执行打印
     *
     * @param count      次数
     * @param targetSign 目标符号
     */
    private void doPrint(int count, SignEnum targetSign) {
        lock.lock();
        try {
            for (int index = 0; index < count; index++) {
                // 如果当前符号为目标符号的上一个符号，执行打印符号
                if (Objects.equals(targetSign.last(), currentSign)) {
                    // 打印目标符号
                    System.out.print(targetSign.name());
                    // 打印分割符，方便观察
                    if (Objects.equals(SignEnum.C, targetSign)) {
                        System.out.print("|");
                    }
                    // 切换当前符号
                    currentSign = targetSign;
                    // 释放锁，通知其他线程
                    // 不能使用signal，如果通知的某个线程不符合条件，进行等待，将会造成程序阻塞
                    condition.signalAll();
                }
                // 不匹配的话，index回退，同时进行等待
                else {
                    index--;
                    condition.await();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

输出
在这里插入图片描述

不使用线程通信

1.Semaphore

/**
 * 通过Semaphore打印
 *
 * @author Administrator
 */
public class SemaphoreTest {

    /**
     * 当前符号
     */
    private volatile SignEnum currentSign = SignEnum.C;
    /**
     * 信号量
     */
    private final Semaphore semaphore = new Semaphore(1);
    /**
     * 自定义线程池
     */
    private final ThreadPoolExecutor executor = new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors(),
            Runtime.getRuntime().availableProcessors() * 2, 5, TimeUnit.MINUTES,
            new LinkedBlockingQueue<>(3), Thread::new, new ThreadPoolExecutor.AbortPolicy());

    /**
     * 打印
     */
    @Test
    @SneakyThrows
    public void testPrint() {
        // 打印B
        Future<?> bFuture = executor.submit(() -> doPrint(33, SignEnum.B));
        // 打印A
        Future<?> aFuture = executor.submit(() -> doPrint(34, SignEnum.A));
        // 打印C
        Future<?> cFuture = executor.submit(() -> doPrint(33, SignEnum.C));
        // 等待打印完成
        while (!aFuture.isDone() || !bFuture.isDone() || !cFuture.isDone()) {
            TimeUnit.MILLISECONDS.sleep(5);
        }
        // 关闭线程池
        executor.shutdown();
    }

    /**
     * 执行打印
     *
     * @param count      次数
     * @param targetSign 目标符号
     */
    @SneakyThrows
    private void doPrint(int count, SignEnum targetSign) {
        for (int index = 0; index < count; index++) {
            // 尝试获取令牌，与锁的效果类似
            if (semaphore.tryAcquire()) {
                try {
                    // 如果当前符号为目标符号的上一个符号，执行打印符号
                    if (Objects.equals(targetSign.last(), currentSign)) {
                        // 打印目标符号
                        System.out.print(targetSign.name());
                        // 打印分割符，方便观察
                        if (Objects.equals(SignEnum.C, targetSign)) {
                            System.out.print("|");
                        }
                        // 切换当前符号+
                        currentSign = targetSign;
                    }
                    // 不匹配的话，index回退
                    else {
                        index--;
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    // 释放令牌
                    semaphore.release();
                }
            }
            // 获取不到令牌，index回退
            else {
                index--;
            }
        }
    }
}

输出
在这里插入图片描述

无锁操作

使用线程通信

1.LockSupport 的 park / unpark

/**
 * 通过LockSupport打印
 *
 * @author Administrator
 */
public class LockSupportTest {

    /**
     * 当前符号
     */
    private volatile SignEnum currentSign = SignEnum.C;
    /**
     * 线程集合
     */
    private final List<Thread> threadList = new ArrayList<>(3);
    /**
     * 自定义线程池
     */
    private final ThreadPoolExecutor executor = new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors(),
            Runtime.getRuntime().availableProcessors() * 2, 5, TimeUnit.MINUTES,
            new LinkedBlockingQueue<>(3), r -> {
        Thread thread = new Thread(r);
        threadList.add(thread);
        return thread;
    }, new ThreadPoolExecutor.AbortPolicy());

    /**
     * 打印
     */
    @Test
    @SneakyThrows
    public void testPrint() {
        // 打印B
        Future<?> bFuture = executor.submit(() -> doPrint(33, SignEnum.B));
        // 打印A
        Future<?> aFuture = executor.submit(() -> doPrint(34, SignEnum.A));
        // 打印C
        Future<?> cFuture = executor.submit(() -> doPrint(33, SignEnum.C));
        // 等待打印完成
        while (!aFuture.isDone() || !bFuture.isDone() || !cFuture.isDone()) {
            TimeUnit.MILLISECONDS.sleep(5);
        }
        // 关闭线程池
        executor.shutdown();
    }

    /**
     * 执行打印
     *
     * @param count      次数
     * @param targetSign 目标符号
     */
    @SneakyThrows
    private void doPrint(int count, SignEnum targetSign) {
        // 不能使用锁，unpark方法不会将锁释放，造成程序阻塞
        for (int index = 0; index < count; index++) {
            // 如果当前符号为目标符号的上一个符号，执行打印符号
            if (Objects.equals(targetSign.last(), currentSign)) {
                // 打印目标符号
                System.out.print(targetSign.name());
                // 打印分割符，方便观察
                if (Objects.equals(SignEnum.C, targetSign)) {
                    System.out.print("|");
                }
                // 切换当前符号
                currentSign = targetSign;
                // 通知其他线程
                Thread currentThread = Thread.currentThread();
                threadList.forEach(thread -> {
                    if (!Objects.equals(currentThread, thread)) {
                        LockSupport.unpark(thread);
                    }
                });
            }
            // 不匹配的话，index回退，同时进行等待
            else {
                index--;
                LockSupport.park();
            }
        }
    }
}

输出
在这里插入图片描述

不使用线程通信

1.CyclicBarrier结合AtomicInteger

/**
 * 通过CyclicBarrier打印
 *
 * @author Administrator
 */
public class CyclicBarrierTest {

    /**
     * 当前符号
     */
    private volatile SignEnum currentSign = SignEnum.C;
    /**
     * 计数器
     */
    private final AtomicInteger atomicInteger = new AtomicInteger();
    /**
     * 篱栅
     */
    private final CyclicBarrier cyclicBarrier = new CyclicBarrier(3, atomicInteger::incrementAndGet);
    /**
     * 自定义线程池
     */
    private final ThreadPoolExecutor executor = new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors(),
            Runtime.getRuntime().availableProcessors() * 2, 5, TimeUnit.MINUTES,
            new LinkedBlockingQueue<>(3), Thread::new, new ThreadPoolExecutor.AbortPolicy());

    /**
     * 打印
     */
    @Test
    @SneakyThrows
    public void testPrint() {
        // 打印B
        executor.execute(() -> doPrint(33, SignEnum.B));
        // 打印A
        executor.execute(() -> doPrint(34, SignEnum.A));
        // 打印C
        executor.execute(() -> doPrint(33, SignEnum.C));
        // 等待打印完成
        while (atomicInteger.get() != 34) {
            TimeUnit.MILLISECONDS.sleep(5);
        }
        // 关闭线程池
        executor.shutdown();
    }

    /**
     * 执行打印
     *
     * @param count      次数
     * @param targetSign 目标符号
     */
    @SneakyThrows
    private void doPrint(int count, SignEnum targetSign) {
        for (int index = 0; index < count; index++) {
            // 如果当前符号为目标符号的上一个符号，执行打印符号
            if (Objects.equals(targetSign.last(), currentSign)) {
                // 打印目标符号
                System.out.print(targetSign.name());
                // 打印分割符，方便观察
                if (Objects.equals(SignEnum.C, targetSign)) {
                    System.out.print("|");
                }
                // 切换当前符号
                currentSign = targetSign;
                // 阻塞等待
                cyclicBarrier.await();
            }
            // 不匹配的话，index回退
            else {
                index--;
            }
        }
        // B,C线程进行阻塞，保证cyclicBarrier走完，否则程序会阻塞
        if (count == 33) {
            cyclicBarrier.await();
        }
    }
}

输出
在这里插入图片描述

2.AtomicInteger

/**
 * 通过AtomicInteger打印
 *
 * @author Administrator
 */
public class AtomicIntegerTest {

    /**
     * 当前符号
     */
    private volatile SignEnum currentSign = SignEnum.C;
    /**
     * 计数器
     */
    private final AtomicInteger counter = new AtomicInteger();
    /**
     * 自定义线程池
     */
    private final ThreadPoolExecutor executor = new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors(),
            Runtime.getRuntime().availableProcessors() * 2, 5, TimeUnit.MINUTES,
            new LinkedBlockingQueue<>(3), Thread::new, new ThreadPoolExecutor.AbortPolicy());

    /**
     * 打印
     */
    @Test
    @SneakyThrows
    public void testPrint() {
        // 打印B
        executor.execute(() -> doPrint(33, SignEnum.B));
        // 打印A
        executor.execute(() -> doPrint(34, SignEnum.A));
        // 打印C
        executor.execute(() -> doPrint(33, SignEnum.C));
        // 等待打印完成
        while (counter.get() != 100) {
            TimeUnit.MILLISECONDS.sleep(5);
        }
        // 关闭线程池
        executor.shutdown();
    }

    /**
     * 执行打印
     *
     * @param count      次数
     * @param targetSign 目标符号
     */
    private void doPrint(int count, SignEnum targetSign) {
        for (int index = 0; index < count; index++) {
            // 如果当前符号为目标符号的上一个符号，执行打印符号
            if (Objects.equals(targetSign.last(), currentSign)) {
                // 打印目标符号
                System.out.print(targetSign.name());
                // 打印分割符，方便观察
                if (Objects.equals(SignEnum.C, targetSign)) {
                    System.out.print("|");
                }
                // 切换当前符号
                currentSign = targetSign;
                // 计数+1
                counter.incrementAndGet();
            }
            // 不匹配的话，index回退
            else {
                index--;
            }
        }
    }
}

输出
在这里插入图片描述

3.CountDownLatch

/**
 * 通过countDownLatch打印
 *
 * @author Administrator
 */
public class CountDownLatchTest {

    /**
     * 当前符号
     */
    private volatile SignEnum currentSign = SignEnum.C;
    /**
     * 计数器
     */
    private final CountDownLatch countDownLatch = new CountDownLatch(100);
    /**
     * 自定义线程池
     */
    private final ThreadPoolExecutor executor = new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors(),
            Runtime.getRuntime().availableProcessors() * 2, 5, TimeUnit.MINUTES,
            new LinkedBlockingQueue<>(3), Thread::new, new ThreadPoolExecutor.AbortPolicy());

    /**
     * 打印
     */
    @Test
    @SneakyThrows
    public void testPrint() {
        // 打印B
        executor.execute(() -> doPrint(33, SignEnum.B));
        // 打印A
        executor.execute(() -> doPrint(34, SignEnum.A));
        // 打印C
        executor.execute(() -> doPrint(33, SignEnum.C));
        // 等待打印完成
        countDownLatch.await();
        // 关闭线程池
        executor.shutdown();
    }

    /**
     * 执行打印
     *
     * @param count      次数
     * @param targetSign 目标符号
     */
    @SneakyThrows
    private void doPrint(int count, SignEnum targetSign) {
        for (int index = 0; index < count; index++) {
            // 如果当前符号为目标符号的上一个符号，执行打印符号
            if (Objects.equals(targetSign.last(), currentSign)) {
                try {
                    // 打印目标符号
                    System.out.print(targetSign.name());
                    // 打印分割符，方便观察
                    if (Objects.equals(SignEnum.C, targetSign)) {
                        System.out.print("|");
                    }
                    // 切换当前符号+
                    currentSign = targetSign;
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    // 计数减1
                    countDownLatch.countDown();
                }
            }
            // 不匹配的话，index回退
            else {
                index--;
            }
        }

    }
}

输出
在这里插入图片描述

Ingcom
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java thread怎么保证线程按顺序执行？如何实现线程排队？
呆咖啡的博客
07-22 282
在Java中，通常不保证多个线程按特定顺序执行，因为线程的调度是由操作系统管理的，并且是不可预测的。
多线程顺序执行，只知道两种？
田维常
07-31 432
本篇是1000期面试系列文章的第94期，持续更新中.....回复“面试”获取优质面试资源！故事 上周一位同学在面试中遇到了这么一道问题：有三个线程T1、T2、T3，如何保证顺序执行？常规操...
java用多线程进行排序算法的比较
06-01
这是一个简单的运用多线程的程序 主要对快速排序等多个算法进行比较
java 多线程按顺序执行、顺序获取结果
T-bright的博客
12-10 4927
文章目录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 {
Java中控制多线程顺序执行
weixin_45295678的博客
09-06 5722
Java的线程调度策略是基于线程优先级的抢占式调度，同优先级的线程的执行顺序是看JVM心情的、不可预测的。那有什么办法来控制多线程按照开发者意愿的顺序执行呢？
线程顺序执行的8种方法，最后一种你用过吗？
张小凡
08-20 8606
面试官：3个线程，按顺序先后执行？
让线程按顺序执行8种方法
Java笔记虾
09-01 1784
作者：俊俊的小熊饼干 cnblogs.com/wenjunwei/p/10573289.html 一.前言 本文使用了8种方法实现在多线程中让线程按顺序运行的方法，涉及到多线程中许多常用的方法，不止为了知道如何让线程按顺序运行，更是让读者对多线程的使用有更深刻的了解。使用的方法如下: [1] 使用线程的join方法 [2] 使用主线程的join方法 [3] 使用线程的wait方法 [...
Java多线程按指定顺序同步执行
08-25
Java多线程按指定顺序同步执行是Java编程中的一种常见问题，即如何让多个线程按照既定的顺序依次执行。下面将介绍三种解决方案，分别使用newSingleThreadExecutor、join方法和ThreadPoolExecutor。 方法1：使用...
让线程按顺序执行8种方法.doc
10-05
本文将介绍让线程按顺序执行的8种方法，涉及到多线程中许多常用的方法，不止为了知道如何让线程按顺序运行，更是让读者对多线程的使用有更深刻的了解。 一、使用线程的join方法 join()是Thread的方法，作用是调用...
Java实现指定线程执行顺序的三种方式示例
08-26
在多线程编程中，我们经常需要让不同的线程按照一定的顺序执行，以避免线程之间的相互干扰和数据不一致的问题。今天，我们将讨论Java实现指定线程执行顺序的三种方式。 第一种方式：通过共享对象锁加上可见变量来...
Java 多线程有序执行的几种方法总结
08-31
Java 多线程有序执行的几种方法总结 Java 多线程有序执行是指在多线程编程中，如何确保线程的执行顺序，避免线程之间的交叉和混淆。下面将总结 Java 中多线程有序执行的几种方法。 一、使用原子递增控制线程准入...
详解三种java实现多线程的方式
09-03
总结来说，Java提供多种方式来创建和管理多线程，每种方式都有其特定的适用场景。继承Thread类适合简单场景，实现Runnable接口更灵活，适用于需要多重继承的类结构。ExecutorService则提供了高级的线程池管理，对于...
java多线程保证顺序执行
大家好，我是云村的王子
09-29 4394
多线程保证顺序执行
让线程顺序运行的11种方法
lyf_zm的博客
04-11 5426
一、让线程顺序运行的11种方法 1 方法说明 使用线程的join方法 使用主线程的join方法 使用线程的wait方法 使用线程的线程池方法 使用线程的Condition（条件变量）方法 使用CountDownLatch（倒计数）的方法 使用线程的CyclicBarrier（回环栅栏）方法 使用线程的Semaphore（信号量）方法 使用LockSupport的park与unpark方法 使用阻塞队列的put与take方法 使用CAS思想来完成多线程的顺序执行AtomicReference<Thre
Java多线程之顺序执行
xtho62的博客
02-20 611
【代码】Java多线程之顺序执行。
保证多线程顺序执行，四种方案，你知道几种？
u011220840的博客
08-03 2226
上周一位同学在面试中遇到了这么一道问题：有三个线程T1、T2、T3，如何保证顺序执行？常规操作，启动三个线程，让其执行。调用三个线程的start方法，很明显是按照顺序调用的，但是每次运行出来的结果，基本上都不相同，随机性特别强。怎么办呢？下面我们使用四种方案来实现。
多线程顺序运行的 4 种方法
y_dzaichirou的博客
12-26 3158
举例：在线程thread2中，加上一句thread1.join()，其意义在于，当前线程2运行到此行代码时会进入阻塞状态，直到线程thread1执行完毕后，线程thread2才会继续运行，这就保证了线程thread1与线程thread2的运行顺序。// 下面三行代码顺序可随意调整，程序运行结果不受影响，因为我们在子线程中通过“join()方法”已经指定了运行顺序。简单说一下子线程与主线程的区别，子线程指的是发生在Thread内部的代码，主线程指的是发生在main函数中的代码。我们可以在main函数中通过。
如何让Java的线程池顺序执行任务？
最新发布
qq_56780627的博客
10-28 1089
Java中的线程池本身并不提供内置的方式来保证任务的顺序执行的，因为线程池的设计目的是为了提高并发性能和效率，如果顺序执行的话，那就和单线程没区别了。但是如果被问到想要实现这个功能该怎么做，有以下两种方式。
多线程中让线程按顺序执行8种方法详解
让一个线程等待另一个线程完成后再继续...对于多线程的使用，这些方法不仅能让线程按照特定顺序执行，还能优化线程的利用以及提高多线程程序的性能。掌握了这些方法，我们可以更加灵活和高效地处理多线程相关的任务。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值