JAVA实现多个线程顺序执行的几种方式

已于 2023-09-01 16:33:27 修改
阅读量6.8k 收藏 37
点赞数 9
分类专栏： 面试_Java 文章标签： java python 开发语言
于 2020-09-26 22:53:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29882585/article/details/108567964
版权

题目描述：如何保证多个线程的顺序执行？

1、join方式实现

join方式即使用Thread.join方法来实现。Thread.join含义当前线程需要等待previousThread线程终止之后才从thread.join返回。简单来说，就是线程没有执行完之前，会一直阻塞在join方法处。

join方式实现方式存在两种：主线程join和执行线程join。下面我们依次来分析一下：

1.主线程join

上面源码就是主线程join的实现方式，其原理就是保证执行线程执行完毕再start后续线程，从而实现多个线程的顺序执行。

2.执行线程join

上面源码就是执行线程join的实现方式，其原理就是通过传入beforeThread（在这个线程执行前需要执行完的线程对象）来保证多个线程顺序执行。

2、CountDownLatch：
 一个线程(或者多个)， 等待另外N个线程完成某个事情之后才能执行。

public static void main(String[] args) {

final CountDownLatch countDownLatch = new CountDownLatch(2);

System.out.println("开始");

new Thread(() -> {
System.out.println("A");
countDownLatch.countDown();
}).start();

new Thread(() -> {
System.out.println("B");
countDownLatch.countDown();
}).start();

countDownLatch.await();
System.out.println("结束");
}

3、使用线程池：

该线程池类似于单线程执行，所以先执行完前一个任务后，再顺序执行下一个任务。
创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行

public static void main(String[] args) {

Thread t1 = new Thread(() -> System.out.println("线程1"), "线程1");
Thread t2 = new Thread(() -> System.out.println("线程2"), "线程2");
Thread t3 = new Thread(() -> System.out.println("线程3"));

ExecutorService executor = Executors.newSingleThreadExecutor();

// 将线程依次加入到线程池中
executor.submit(t1);
executor.submit(t2);
executor.submit(t3);

// 及时将线程池关闭
executor.shutdown();

}

4、CompletableFuture

public static void main(String[] args) {

Thread t1 = new Thread(() -> System.out.println("线程1"), "线程1");
Thread t2 = new Thread(() -> System.out.println("线程2"), "线程2");
Thread t3 = new Thread(() -> System.out.println("线程3"));

CompletableFuture.runAsync(() -> t1.start())
.thenRun(() -> t2.start())
.thenRun(() -> t3.start());

}

题目描述：建立三个线程A、B、C，A线程打印10次字母A，B线程打印10次字母B,C线程打印10次字母C，但是要求三个线程同时运行，并且实现交替打印，即按照ABCABCABC的顺序打印。

一Synchronized同步法

1、基本思路

使用同步块和wait、notify的方法控制三个线程的执行次序。具体方法如下：从大的方向上来讲，该问题为三线程间的同步唤醒操作，主要的目的就是ThreadA->ThreadB->ThreadC->ThreadA循环执行三个线程。为了控制线程执行的顺序，那么就必须要确定唤醒、等待的顺序，所以每一个线程必须同时持有两个对象锁，才能进行打印操作。一个对象锁是prev，就是前一个线程所对应的对象锁，其主要作用是保证当前线程一定是在前一个线程操作完成后（即前一个线程释放了其对应的对象锁）才开始执行。还有一个锁就是自身对象锁。主要的思想就是，为了控制执行的顺序，必须要先持有prev锁（也就前一个线程要释放其自身对象锁），然后当前线程再申请自己对象锁，两者兼备时打印。之后首先调用self.notify()唤醒下一个等待线程（注意notify不会立即释放对象锁，只有等到同步块代码执行完毕后才会释放），再调用prev.wait()立即释放prev对象锁，当前线程进入休眠，等待其他线程的notify操作再次唤醒。

public class ABC_Synch {
    public static class ThreadPrinter implements Runnable {
        private String name;
        private Object prev;
        private Object self;

        private ThreadPrinter(String name, Object prev, Object self) {
            this.name = name;
            this.prev = prev;
            this.self = self;
        }

        @Override
        public void run() {
            int count = 10;
            while (count > 0) {// 多线程并发，不能用if，必须使用whil循环
                synchronized (prev) { // 先获取 prev 锁
                    synchronized (self) {// 再获取 self 锁
                        System.out.print(name);// 打印
                        count--;

                        self.notifyAll();// 唤醒其他线程竞争self锁，注意此时self锁并未立即释放。
                    }
                    // 此时执行完self的同步块，这时self锁才释放。
                    try {
                        if (count == 0) {// 如果count==0,表示这是最后一次打印操作，通过notifyAll操作释放对象锁。
                            prev.notifyAll();
                        } else {
                            prev.wait(); // 立即释放 prev锁，当前线程休眠，等待唤醒
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    public static void main(String[] args) throws Exception {
        Object a = new Object();
        Object b = new Object();
        Object c = new Object();
        ThreadPrinter pa = new ThreadPrinter("A", c, a);
        ThreadPrinter pb = new ThreadPrinter("B", a, b);
        ThreadPrinter pc = new ThreadPrinter("C", b, c);

        new Thread(pa).start();
        Thread.sleep(10);// 保证初始ABC的启动顺序
        new Thread(pb).start();
        Thread.sleep(10);
        new Thread(pc).start();
        Thread.sleep(10);
    }
}

可以看到程序一共定义了a,b,c三个对象锁，分别对应A、B、C三个线程。A线程最先运行，A线程按顺序申请c,a对象锁，打印操作后按顺序释放a,c对象锁，并且通过notify操作唤醒线程B。线程B首先等待获取A锁，再申请B锁，后打印B，再释放B，A锁，唤醒C。线程C等待B锁，再申请C锁，后打印C，再释放C,B锁，唤醒A。看起来似乎没什么问题，但如果你仔细想一下，就会发现有问题，就是初始条件，三个线程必须按照A,B,C的顺序来启动，但是这种假设依赖于JVM中线程调度、执行的顺序。

二、Lock锁方法

1、基本思路

通过ReentrantLock我们可以很方便的进行显式的锁操作，即获取锁和释放锁，对于同一个对象锁而言，统一时刻只可能有一个线程拿到了这个锁，此时其他线程通过lock.lock()来获取对象锁时都会被阻塞，直到这个线程通过lock.unlock()操作释放这个锁后，其他线程才能拿到这个锁。

2、代码

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ABC_Lock {
    private static Lock lock = new ReentrantLock();// 通过JDK5中的Lock锁来保证线程的访问的互斥
    private static int state = 0;//通过state的值来确定是否打印

    static class ThreadA extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 10;) {
                try {
                    lock.lock();
                    while (state % 3 == 0) {// 多线程并发，不能用if，必须用循环测试等待条件，避免虚假唤醒
                        System.out.print("A");
                        state++;
                        i++;
                    }
                } finally {
                    lock.unlock();// unlock()操作必须放在finally块中
                }
            }
        }
    }

    static class ThreadB extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 10;) {
                try {
                    lock.lock();
                    while (state % 3 == 1) {// 多线程并发，不能用if，必须用循环测试等待条件，避免虚假唤醒
                        System.out.print("B");
                        state++;
                        i++;
                    }
                } finally {
                    lock.unlock();// unlock()操作必须放在finally块中
                }
            }
        }
    }

    static class ThreadC extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 10;) {
                try {
                    lock.lock();
                    while (state % 3 == 2) {// 多线程并发，不能用if，必须用循环测试等待条件，避免虚假唤醒
                        System.out.print("C");
                        state++;
                        i++;
                    }
                } finally {
                    lock.unlock();// unlock()操作必须放在finally块中
                }
            }
        }
    }

    public static void main(String[] args) {
        new ThreadA().start();
        new ThreadB().start();
        new ThreadC().start();
    }
}

三、ReentrantLock结合Condition

1、基本思路

与ReentrantLock搭配的通行方式是Condition，如下：

private Lock lock = new ReentrantLock();  
private Condition condition = lock.newCondition(); 
condition.await();//this.wait();  
condition.signal();//this.notify();  
condition.signalAll();//this.notifyAll();

Condition是被绑定到Lock上的，必须使用lock.newCondition()才能创建一个Condition。从上面的代码可以看出，Synchronized能实现的通信方式，Condition都可以实现，功能类似的代码写在同一行中。这样解题思路就和第一种方法基本一致，只是采用的方法不同。

2、代码

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ABC_Condition {
    private static Lock lock = new ReentrantLock();
    private static Condition A = lock.newCondition();
    private static Condition B = lock.newCondition();
    private static Condition C = lock.newCondition();

    private static int count = 0;

    static class ThreadA extends Thread {
        @Override
        public void run() {
            try {
                lock.lock();
                for (int i = 0; i < 10; i++) {
                    while (count % 3 != 0)//注意这里是不等于0，也就是说在count % 3为0之前，当前线程一直阻塞状态
                        A.await(); // A释放lock锁
                    System.out.print("A");
                    count++;
                    B.signal(); // A执行完唤醒B线程
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }

    static class ThreadB extends Thread {
        @Override
        public void run() {
            try {
                lock.lock();
                for (int i = 0; i < 10; i++) {
                    while (count % 3 != 1)
                        B.await();// B释放lock锁，当前面A线程执行后会通过B.signal()唤醒该线程
                    System.out.print("B");
                    count++;
                    C.signal();// B执行完唤醒C线程
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }

    static class ThreadC extends Thread {
        @Override
        public void run() {
            try {
                lock.lock();
                for (int i = 0; i < 10; i++) {
                    while (count % 3 != 2)
                        C.await();// C释放lock锁
                    System.out.print("C");
                    count++;
                    A.signal();// C执行完唤醒A线程
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new ThreadA().start();
        new ThreadB().start();
        new ThreadC().start();
    }
}

四、Semaphore信号量方式

1、基本思路

Semaphore又称信号量，是操作系统中的一个概念，在Java并发编程中，信号量控制的是线程并发的数量。

public Semaphore(int permits)

其中参数permits就是允许同时运行的线程数目;

Semaphore是用来保护一个或者多个共享资源的访问，Semaphore内部维护了一个计数器，其值为可以访问的共享资源的个数。一个线程要访问共享资源，先获得信号量，如果信号量的计数器值大于1，意味着有共享资源可以访问，则使其计数器值减去1，再访问共享资源。如果计数器值为0,线程进入休眠。当某个线程使用完共享资源后，释放信号量，并将信号量内部的计数器加1，之前进入休眠的线程将被唤醒并再次试图获得信号量。

Semaphore使用时需要先构建一个参数来指定共享资源的数量，Semaphore构造完成后即是获取Semaphore、共享资源使用完毕后释放Semaphore。

Semaphore semaphore = new Semaphore(10,true);  
semaphore.acquire();  
//do something here  
semaphore.release();

2、代码

import java.util.concurrent.Semaphore;

public class ABC_Semaphore {
    // 以A开始的信号量,初始信号量数量为1
    private static Semaphore A = new Semaphore(1);
    // B、C信号量,A完成后开始,初始信号数量为0
    private static Semaphore B = new Semaphore(0);
    private static Semaphore C = new Semaphore(0);

    static class ThreadA extends Thread {
        @Override
        public void run() {
            try {
                for (int i = 0; i < 10; i++) {
                    A.acquire();// A获取信号执行,A信号量减1,当A为0时将无法继续获得该信号量
                    System.out.print("A");
                    B.release();// B释放信号，B信号量加1（初始为0），此时可以获取B信号量
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    static class ThreadB extends Thread {
        @Override
        public void run() {
            try {
                for (int i = 0; i < 10; i++) {
                    B.acquire();
                    System.out.print("B");
                    C.release();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    static class ThreadC extends Thread {
        @Override
        public void run() {
            try {
                for (int i = 0; i < 10; i++) {
                    C.acquire();
                    System.out.println("C");
                    A.release();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new ThreadA().start();
        new ThreadB().start();
        new ThreadC().start();
    }
}

参考：多线程交替打印ABC的多种实现方法_多线程打印abc_想作会飞的鱼的博客-CSDN博客

          百度安全验证

https://www.cnblogs.com/csnjava/p/17242714.html

-Sloth-
关注
  • 9
    点赞
  • 踩
  • 37
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
三个线程按顺序打印ABC？十二种做法，深入多线程同步通信机制
代码界的扛把子
05-31 342
public static void printA() { //通过循环，hang住线程 while (state < 4) { try { //获取锁 lock.lock();
Java 多线程有序执行的几种方法总结
08-31
Java 多线程有序执行的几种方法总结 Java 多线程有序执行是指在多线程编程中，如何确保线程的执行顺序，避免线程之间的交叉和混淆。下面将总结 Java 中多线程有序执行的几种方法。 一、使用原子递增控制线程准入...
有三个线程，分别只能打印A，B和C要求按顺序打印ABC，打印10次(多种方法,小白也懂)
qq_62718027的博客
06-22 2404
就...相当于创建三十个线程了....如果实在想不起来其他方法就用这个吧....那么我们就可以让三个线程按顺序阻塞和解锁,就能完成打印。简单来说我们有一个名为LockSupport的方法。实际上就是把第一种方式换为用这种方式实现。我们要循环打印ABC三个线程的三个字母。unpark就是取消阻塞让其继续执行。同样还是控制加锁顺序和解锁顺序罢了。park就是阻塞当前进程。
java并发-如何保证线程按照顺序执行？
最新发布
PacosonSWJTU的博客
06-09 390
最简单。
任务编排：CompletableFuture从入门到精通
Java技术攻略的博客
03-22 1651
最近遇到了一个业务场景，涉及到多数据源之间的请求的流程编排，正好看到了一篇某团介绍CompletableFuture原理和使用的技术文章，主要还是涉及使用层面。网上很多文章涉及原理的部分讲的不是特别详细且比较抽象。因为涉及到多线程的工具必须要理解原理，不然一旦遇到问题排查起来就只能凭玄学，正好借此梳理一下CompletableFuture的工作原理。
三个线程轮流打印ABC
Infor_learning的博客
07-14 6842
1、多线程if和where的区别： 就是用if判断的话，唤醒后线程会从wait之后的代码开始运行，但是不会重新判断if条件，直接继续运行if代码块之后的代码，而如果使用while的话，也会从wait之后的代码运行，但是唤醒后会重新判断循环条件，如果不成立再执行while代码块之后的代码块，成立的话继续wait。 2、 一.概述wait()方法可以使线程进入等待状态，而notify()可以使等待的状态唤醒 wait，notify和notifyAll方法是Object类的成员函数，所以Java的任何一个.
线程的几个状态
chushouxiu0552的博客
03-13 239
1.新建状态(New) : 线程对象被创建后，就进入了新建状态。例如，Thread thread = new Thread()。 2.就绪状态(Runnable): 也被称为“可执行状态”。线程对象被创建后，其它线程调用了该对象的start()方法，从而来启动该线程。例如，...
Java多线程交叉打印ABABAB，一个线程打印A，一个线程打印B
江湖人称小程的博客
10-26 4928
在Java中想要完成此功能有好几种方法都可以实现，这篇文章主要使用 wait 和 notifyAll 方法。 具体需求为： 要求先打印字符 A ，再打印字符 B ，完了再打印字符 A …如此循环下去，要求格式为：ABABABABABAB… 原理： 首先需要两个线程，一个打印字符 A ，另一个打印字符 B ，那么如何让他们互相协作呢？此时，我需要一个 boolean 类型的变量 flag ，这个变量...
Java线程池的执行流程
学亮编程手记
05-30 1492
如果工作队列已满且线程池中的线程数已达到最大线程数，新提交的任务将根据设定的拒绝策略进行处理。而当有新任务提交时，如果没有可用的核心线程，线程池会根据需要创建新的线程来处理任务。非核心线程（超过核心线程数的线程）的创建也是按需进行的。如果线程池中的线程都在执行其他任务，新提交的任务将被放入工作队列中等待执行。所以，对于核心线程的创建并不是在线程池创建的时候就完成的，而是在有新任务提交时按需创建。如果还有其他问题，请随时提问。当你创建一个线程池并初始化时，会立即创建核心线程，以满足指定的核心线程数（
java中线程挂起的几种方式详解
08-25
Java中线程挂起的几种方式详解是Java编程中一个常见的技术，主要用于控制线程的执行和暂停。在Java中提供了三种方式来实现线程挂起：suspend/resume、wait/notify、notifyAll和park/unpark。 1. suspend/resume方式...
Java线程间的通信方式详解
09-02
而且，当多个线程需要等待特定条件时，通常更推荐使用Java的`wait()` 和 `notify()` 方法，或者使用`CountDownLatch`、`CyclicBarrier`、`Semaphore`等高级同步工具。 总结起来，Java线程间的通信是保证程序并发...
C# 不使用Task实现的多线程顺序执行
06-19
多线程有很好的并发性即无序性，在某些特殊情况下需要用到多线程然而又要使其具备顺序性，这种时候就有了一个特殊的场景那就是多线程顺序执行，在现在VS2015中Task自带了顺序执行的方法，但在此之前的旧项目中如果需要使用多线程顺序执行该怎么办呢？Task又是怎么实现的呢？这里提供了一种类似Task顺序执行多线程的实现(可能跟Task的原理有很大区别)，希望对大家能有帮助，对此类问题的实现有更好的思路和技巧的同学欢迎留言，大家一起探讨。
java多线程下载文件
07-14
2. **多线程同步**：当多个线程操作同一份资源时，可能引发数据不一致问题。Java提供了多种同步机制，如`synchronized`关键字、`Lock`接口、`Semaphore`信号量等，用于控制线程的并发访问，确保数据的一致性和完整性...
浅析java volatitle 多线程问题
09-05
因此，如果一个变量可能被多个线程同时修改，单纯使用`volatile`可能不足以保证数据一致性。 使用`volatile`的一些建议： 1. **避免过度使用**：`volatile`会影响JVM的优化，因为它阻止了指令重排序，可能会降低...
java多线程-同步块实例讲解
09-01
同步块的目的是防止多个线程同时访问共享资源，从而避免数据竞争问题。以下是几种不同类型的同步块： 1. 实例方法同步：当在实例方法前加上`synchronized`关键字时，整个方法会被视为同步块。这意味着任何时刻只有...
Java多线程编程
05-02
Java多线程编程是Java开发中的重要组成部分，它允许程序同时执行多个任务，极大地提高了程序的效率和响应性。在Java中，多线程主要通过`Thread`类和并发工具来实现，接下来我们将深入探讨这些关键知识点。 1. **...
后台模仿promise.all实现异步，提升代码速度
weixin_42499566的博客
08-25 358
后台模仿promise.all实现异步，提升代码速度
java多线程排序_多线程排序
weixin_34247523的博客
02-16 382
import java.util.*;import java.util.concurrent.CountDownLatch;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.locks.Lock;import java.util....
Java多线程——信号量Semaphore是啥
Arya的博客，专注后端领域
03-05 977
Java多线程——信号量Semaphore是啥。
java 多线程控制执行顺序
09-27
在Java中，有几种方法可以控制多线程的执行顺序。首先，可以使用线程的join()方法来将线程排好执行顺序。join()方法会让主线程等待子线程执行完毕后再继续执行。其次，可以利用Java中的等待/通知机制来控制线程的执行顺序。通过使用synchronized关键字、Object的wait()和notify()方法，或者使用ReentrantLock、Condition、CountDownLatch和Semaphore等类，可以实现线程的有序执行。另外，Java还提供了一个单例线程池newSingleThreadExecutor，它可以保证多个任务按照顺序一个接一个地执行。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值