控制并发流程，做好线程间的协调

最新推荐文章于 2024-05-14 10:57:17 发布
最新推荐文章于 2024-05-14 10:57:17 发布
阅读量549 收藏
点赞数
文章标签： java 面试 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qynwang/article/details/131225261
版权

一、概述

1. 什么是控制并发流程？

线程一般是由线程调度器自动控制的，但有些场景需要按照我们程序员的意愿去实现多线程之间相互配合，从而满足业务逻辑。比如：

  • 让线程A等待线程B执行完后再执行等一些相互合作的逻辑；
  • 或一系列线程等待一个线程运行完毕或发出信号之后再执行

2. 控制并发流程工具类

在这里插入图片描述

二、 CountDownLatch 倒计时门栓

倒数（向下计数、倒着计数）count为0后，那些执行了 await() 方法陷入阻塞的线程就被唤醒继续执行。就像去做过山车时，等到空余座位为0时，就会发车。

1. 主要方法介绍

  • CountDownLatch(int count)：仅有这一个构造函数，参数count为需要倒数的数值。
  • await()： 调用 await() 方法的线程会被挂起，它会等待直到count值为0才继续执行。
  • countDown() ：将count值减1，等到为0时，那些等待的线程会被唤起。

2. 图解

  • 在构造方法中指定倒数count值；
  • 调用await的线程Ta会被挂起；
  • 每调用countDown()，倒数count会减1；但是该线程不会被挂起，依然执行
  • 当倒数count值为0时，之前执行await的线程就被唤醒，开始执行

3、代码演示

（1）用法①：一等多

一个线程等待多个线程都发出信号后，再继续自己的工作：

/**
 *      工厂中，质检，5个工人检查，当5个人都认为通过，才认为这个质检通过
 */
public class CountDownLatchDemo1 {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(5);//指定倒数count为5
        ExecutorService pool = Executors.newFixedThreadPool(5);//线程池创建5个线程

        //5次任务质检
        for (int i = 0; i < 5; i++) {
            int no = i+1;
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep((long) (Math.random() * 10000));
                        System.out.println("No." + no + ":质检完毕");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        countDownLatch.countDown();//倒计count减1
                    }
                }
            };

            pool.submit(runnable);
        }
        System.out.println("等待5个人质检完。。。。。");
        countDownLatch.await();//主线程等待倒时count=0，释放所有挂起线程，并主线进行工作
        System.out.println("质检完成");

    }
    
}

image-20230615103516182

(2) 用法②：多等一

多个线程等待某个线程发出信号后，同时开始执行

/**
 *      模拟100m跑步，5名选手都准备好了，只能裁判员一生令下，5人同时跑出
 */
public class CountDownLatchDemo2 {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(1);
        ExecutorService pool = Executors.newFixedThreadPool(5);//线程池创建5个线程

        for (int i = 0; i < 5; i++) {
            int no = i+1;
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    System.out.println("NO." + no + ":准备完毕，等待发令");
                    try {
                        countDownLatch.await();
                        System.out.println("No." + no + ":开始跑步");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
            pool.submit(runnable);
        }
        //主线程，模拟裁判员
        Thread.sleep(5000);
        System.out.println("发令枪响，比赛开始");
        countDownLatch.countDown();
    }
}

（3）综合用法：多等一 & 一等多

多等一：5名运动员等待裁判员打枪开跑；一等多：裁判员等5名运动员到达终点；

/**
 *      模拟100m跑步，5名选手都准备好了，只能裁判员一生令下，5人同时跑出，当所有人都到终点后，比赛结束
 */
public class CountDownLatchDemo3 {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch begin = new CountDownLatch(1);
        CountDownLatch end = new CountDownLatch(5);
        ExecutorService pool = Executors.newFixedThreadPool(5);//线程池创建5个线程

        for (int i = 0; i < 5; i++) {
            int no = i+1;
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    System.out.println("NO." + no + ":准备完毕，等待发令");
                    try {
                        begin.await();
                        System.out.println("No." + no + ":开始跑步");
                        Thread.sleep((long) (Math.random()*10000));
                        System.out.println("No." + no + ":到达终点");
                        
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }finally {
                        end.countDown();
                    }
                }
            };
            pool.submit(runnable);
        }
        //主线程，模拟裁判员
        Thread.sleep(5000);
        System.out.println("发令枪响，比赛开始");
        begin.countDown();
        end.await();
        System.out.println("比赛结束！");
    }
}

4、注意点

  • 他不能重复使用，当倒数count=0，该实例就失效了；
  • 如果要再次使用，需要再实例化新的对象
  • 可以实现多等多的情况

三、Semaphore 信号量

1. 作用

对于一些重量级服务，如执行时间长、处理消耗资源大，设置一下同时并发执行任务的线程个数，从而保障服务平稳运行。

  • 用来限制或管理数量的有限资源的使用情况
  • 类似于生活中的"许可证"，许可证数量有限，并且只有拿到“许可证”的线程才允许运行

2. 图解

3. 重要方法

  • new Semaphore(int permits,boolean fair)：初始化Semaphore并指定许可证的数量。这里可以设置是否使用公平策略，如果传入true，那么Semaphore会把之前等待的线程放到FIFO的队列里，以便于当有了新的许可证可以分发给之前等了最长时间的线程；
  • tryAcquire() ：看看现在有没有空闲的许可证，如果有的话就获取，如果没有的话也没关系，我不会陷入阻塞，我可以去做别的事，过一会再来查看许可证的空闲情况。
  • tryAcquire(timeout): 和tryAcquire() 一样，但是多了一个超时时间，比如“在3秒内获取不到许可证，我就去做别的事”
  • acquire()：获取许可证，可响应中断
  • acquireUninterruptibly()：获取许可证，拒绝响应中断
  • release()：释放许可证

4、代码演示

（1）一般用法：
public class SemaphoreDemo {
    static Semaphore semaphore = new Semaphore(3,true);
    public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(50);

        for (int i = 0; i < 100; i++) {
            pool.submit(new Task());
        }
        pool.shutdown();

    }
    static class Task implements Runnable{
        @Override
        public void run() {
            try {
                semaphore.acquire();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+":拿到许可证");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+":释放许可证");
            semaphore.release();
        }
    }
}

image-20230615110440704

(2) 特殊用法

一次性获取或释放多个许可证。

public class SemaphoreDemo {

    static Semaphore semaphore = new Semaphore(5, true);

    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(50);
        for (int i = 0; i < 100; i++) {
            service.submit(new Task());
        }
        service.shutdown();
    }

    static class Task implements Runnable {

        @Override
        public void run() {
            try {
                semaphore.acquire(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "拿到了许可证");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "释放了许可证");
            semaphore.release(3);
        }
    }
}

什么时候需要一次性获取多个许可证：

比如 TaskA 会调用很消耗资源的 method1()，而 TaskB 调用的是不太消耗资源的 method2()，假设我们一共有5个许可证。那么我们就可以要求 TaskA 获取5个许可证才能执行，而 TaskB 只需要获取到一个许可证就能执行，这样就避免了A和B同时运行的情况，我们可以根据自己的需求，通过分配许可证的方式合理分配资源。

5、注意点

  • 获取&释放的许可证数量要求必须一致，否则程序运行到最后，许可证都会被占用，就会都陷入阻塞
  • 根据情况设置公平性，一般设置为true，这样可以避免线程饥饿
  • 释放和获取对线程没有要求，可以由这个线程A获取，别的线程B释放
  • 可以将它实现成一个轻量级的CountDownLatch，比如信号量Semaphore的许可证数量为1，线程A获取到，线程B执行 acquire() 再获取时，就会陷入阻塞，线程A 执行release() 之后，线程B才能执行，相当于 CountDownLatch 的唤醒

四、Condition条件对象

1. 作用

当线程1需要等待某个条件的时候，它就去执行condition.await0方法，一旦执行了await0方法，线程就会进入阻塞状态。

然后通常会有另外一个线程，假设是线程2，去执行对应的条件，直到这个条件达成的时候，线程2就会去执行condition.signal() 方法，这时JVM就会从被阻塞的线程里，找到那些等待该condition的线程，这时线程1就会收到可执行信号，它的线程状态就会变成Runnable可执行状态

2. 图解

3、signalAll() 和 signal() 的区别

  • signalAll()唤醒所有等待的线程，signal()唤醒一个
  • signal()是公平的，会唤醒等待时间最长的线程

4、代码演示

（1）基本用法

condition一般是绑定在锁lock上面的，基本用法如下：

public class ConditionDemo1 {
    private ReentrantLock lock = new ReentrantLock();
    private Condition condtion = lock.newCondition();

    void method1() throws InterruptedException {
        lock.lock();
        try{
            System.out.println("条件不满足，开始wait");
            condtion.await();
            System.out.println("条件满足，开始执行后续的任务");
        }finally {
            lock.unlock();
        }
    }

    void method2(){
        lock.lock();
        try{
            System.out.println("准备工作完成，开始唤醒其他线程");
            condtion.signal();
        }finally {
            lock.unlock();
        }
    }

    //主函数
    public static void main(String[] args) throws InterruptedException {
        ConditionDemo1 demo1 = new ConditionDemo1();
        //主线程创建一个线程1
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                    demo1.method2();//线程1，1秒后，唤醒主线程
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        demo1.method1();//主线程阻塞
    }
    
}

image-20230615112138646

（2）用Condition实现生产者消费者模式
/**
 *      演示Condition实现生产者消费者模式
 */
public class ConditionDemo2 {
    private static int queueSize = 10;
    private static PriorityQueue<Integer> queue = new PriorityQueue<>(queueSize);

    private static ReentrantLock lock = new ReentrantLock();
    private static Condition noFull = lock.newCondition();
    private static Condition notEmpty = lock.newCondition();

    //消费者
    static class Consumer extends Thread {
        @Override
        public void run() {
            comsume();
        }

        //消费操作
        void comsume(){
            while (true){
                lock.lock();
                try {
                    while (queue.size()==0){
                        System.out.println("队列空，等待数据");
                        notEmpty.await();
                    }
                    queue.poll();
                    noFull.signalAll();
                    System.out.println("从队列里取走了一个数据，队列还剩余空间"+(queueSize-queue.size())+"个元素");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //生产者
    static class Producer extends Thread {
        @Override
        public void run() {
            produce();
        }

        //生产操作
        void produce(){
            while (true){
                lock.lock();
                try {
                    while (queue.size()==queueSize){
                        System.out.println("队列满，等待消费");
                        noFull.await();
                    }
                    queue.offer(1);
                    notEmpty.signalAll();
                    System.out.println("给队列生成了一个数据，队列有"+queue.size()+"个元素");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //主函数
    public static void main(String[] args) {
        Consumer consumer = new Consumer();
        Producer producer = new Producer();
        consumer.start();
        producer.start();
    }

}

5. 注意点

  • 实际上，如果说Lock可以用来代替synchronized，那么Condition就可以用来代替相对应的Obiect.wait/notify的，所以Condition在用法和性质上，几乎和Obiect.wait/notify都一样
  • await方法执行后会自动释放持有的Lock锁，和Object.wait一样，不需要自己手动先释放锁
  • 调用await的时候，必须持有锁，否则会抛出异常，和Object.wait一样

五、CyclicBarrier循环栅栏

1. 作用

  • CyclicBarrier循环栅栏和CountDownLatch很类似，都能阻塞一组线程
  • 当有大量线程相互配合，分别计算不同任务，并且需要最后统汇总的时候，我们可以使用CyclicBarrier。CvclicBarrier可以构造一个集结点，每一个线程执行完毕后，都会到集结点等待，直到所有线程都到了集结点，那么该栅栏就被撤销，所有线程再统一出发，继续执行剩下的任务
  • 就像我们在生活中聚会时，首先约定咱们3个人明天中午在学校碰面，都到齐后再一起继续接下来的安排。
  • CyclicBarrier循环栅栏是可以重复使用的，这一点和 CountDownLatch 不一样

2、代码演示

public class CyclicBarrierDemo {
    public static void main(String[] args) {
        //参数1：设置几个等待数
        //参数2：当线程数满足条件后，执行的任务
        CyclicBarrier cyclicBarrier = new CyclicBarrier(5, new Runnable() {
            @Override
            public void run() {
                System.out.println("五个到齐，走一波");
                System.out.println(Thread.currentThread().getName());
            }
        });

        //创建10个线程
        for (int i = 0; i < 10; i++) {
            new Thread(new Task(i,cyclicBarrier)).start();
        }

    }

    static class Task implements Runnable{
        private int id;
        private CyclicBarrier cyclicBarrier;

        public Task(int id, CyclicBarrier cyclicBarrier) {
            this.id = id;
            this.cyclicBarrier = cyclicBarrier;
        }

        @Override
        public void run() {
            System.out.println("线程"+id+"，现在前往集合地点");
            try {
                Thread.sleep((long) (Math.random()*10000));
                System.out.println("线程"+id+":达到集合地点，开始等待其他人到达");
                cyclicBarrier.await();//陷入等待
                System.out.println("线程"+id+":出发了！！！");
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
    }

}

每当凑齐五个之后，就出发一波，cyclicBarrier可以被重复使用。

3、CountDownLatch & CyclicBarrier 的区别

  • 作用不同

    • CountDownLatch：对应的是事件，完成某个事件就可以调用countDown()，一个线程可执行多次countDown()，且该线程不会阻塞
    • CyclicBarrier：对应的是线程，每个线程都执行await()，线程执行完await()会阻塞，达到指定的数量才会继续运行，

  • 可重用性不同

    • CountDownLatch：倒数count到0之后，该实例就不能再使用
    • CyclicBarrier：满足指定的数量条件后，就继续执行，且可再次使用

  • 结束后统一工作

    • CountDownLatch：结束后就只是唤醒线程继续工作
    • CyclicBarrier：可以在CyclicBarrier的构造函数中自定义 runnable 任务，结束后会执行该任务

点我扫码关注微信公众号

文章来源：控制并发流程，做好线程间的协调

个人微信：CaiBaoDeCai

微信公众号名称：Java知者

微信公众号 ID： JavaZhiZhe

谢谢关注！

Java知者
关注
(二) java并发编程--为什么使用多线程
Xinghf
11-18 808
（一）并发历史 (1.1) 计算机硬件 在计算机发展早期，计算机还没有操作系统；自始至终的执行一个程序，这个程序直接访问机器的所有资源。每次只运行一个程序，不能很好的利用稀缺的计算机资源。 (1.2 ) 操作系统的诞生 操作系统的诞生让多个程序可以同时运行，程序在各自的进程（process）中运行，互相分离，各自独立运行，有操作系统来分配资源，比如内存、文件句柄、安全证书。如果需要
Java 并发编程解析 | 如何正确理解Java领域中的多线程模型，主要用来解决什么问题?
guanshengg的博客
08-16 307
作为一名Java Developer，在面对Java并发编程的时候，有过哪些的疑惑与不解 ？对于Java领域中的线程机制与多线程，你都做了哪些功课？是否和我一样，在看完《Java编程思想》和《Java并发编程实战》之后，依旧一头雾水，不知其迹？那么，希望你看完此篇文章之后，对你有所帮助...
并发控制
weixin_30273175的博客
07-01 94
并发控制 1. 并发冲突 当两个进程试图在同一时间修改同一数据，就会产生冲突。 2. 并发控制 有两种方式管理并发数据访问：乐观并发控制、悲观并发控制。 这两种控制模式的区别在于，是在冲突发生前进行防止，还是在发生后采用某种方法来处理冲突。 3. 悲观并发控制 悲观并发模式假定系统中存在足够多的数据修改操作，以致任何确定的读操作都可能会受到由别的用户所制造的数...
控制并发
小知识折射大智慧
01-03 223
Go 拥有强大的并发特性，我们该如何控制并发呢？控制并发的场景还是挺常见的，可能我们担心并发数太高对系统产生其他影响。 针对具体的一些场合，我们可以利用 map 数据类型进行并发控制，只要我们固定一定数量的 key 就可以实现。 结合一个实际的例子，我们监控用户在聊天区的内容，比如我们的处理任务只想启动 128 个协程来并发处理这些数据。 ①我们可以根据用户的 UID 进行取模运算，我们在处理数据时，首先获取用户 UID 和 128 取模运算后的结果作为 key，然后去 map 中查看 key 是否存在，
Go select的并发模式：探索常见的并发控制模式（并发控制模式探索）
Go语言的并发模型在多线程编程语言中独树一帜，它通过轻量级的线程goroutines和通信顺序进程channels（简称channel）实现高效的并发程序。而select语句则是Go语言并发编程中的一个核心组件，它支持从多个并发通道中...
Java集合并发问题分析：保证线程安全的策略
![Java集合并发问题分析：保证线程安全的策略]...集合框架中的类可以分为同步和非同步两种，这对于处理多线程并发访问场景下的数据安全问题至关重要。 ## 1.2 集合的并发问题 在多线程
httplib2并发请求秘籍：多线程与异步IO的应用宝典
[httplib2并发请求秘籍：多线程与异步IO的应用宝典](https://opengraph.githubassets.com/5ea42bb9562bb824b0e2f1d6b6a0a6c5e2cda8e55ee792022b328075baa69e47/httplib2/httplib2) # 1. 并发请求基础和httplib2概述 ...
并发的控制方法
qq_39630624的博客
08-17 987
文章目录Java内存模型同步关键字synchronizedReentrantLock重入锁ReadWriteLock读写锁Condition对象Semaphore信号量ThreadLocal线程局部变量 Java内存模型 在Java中，每一个线程都有自己的独立的一块工作内存区，其中存放着被所有线程共享的主存中的变量的拷贝值。当线程执行时，它在自己的工作内存中操作这些变量。为了让线程中私有的值与共享相同，线程需要进行一系列的操作，并且每个操作均为原子的。如下图： 由于每个线程都有自己的工作内存区，因此当一个
11.1 并发控制
tang7mj的博客
12-09 76
多用户数据库系统：允许多个用户同时访问和操作数据库。事务的并行执行：为了提高资源利用率和系统效率，多个事务应该并行（并发）执行。并发执行的方式单处理机系统：交叉并发方式，事务操作轮流执行。多处理机系统：同时并发方式，多个处理机同时运行不同事务。并发操作的必要性：多用户数据库系统允许多个事务并行执行，提高系统效率和资源利用率。并发操作的问题：包括丢失修改、不可重复读和读“脏”数据等数据不一致性问题。并发控制技术。
面试官：假如有几十个请求，如何去控制并发？
最新发布
小相探索IT世界
05-14 1297
控制并发请求是一个重要的问题，特别是在面对高并发情况时，合理地管理请求可以有效地维护系统的稳定性和性能。：使用线程池来管理并发请求，通过限制线程数量和队列大小，可以控制同时处理的请求数量，避免系统因过多的请求而崩溃或性能下降。：使用信号量来限制并发请求的数量，通过控制信号量的数量来控制允许同时处理的请求数量，超过限制的请求将被阻塞或拒绝。：采用限流算法来控制请求的流量，例如令牌桶算法、漏桶算法等，可以根据系统的处理能力和资源情况来限制请求的发送速率，避免系统被过多的请求压垮。
多线程学习笔记-4.多线程并发控制流程
xingzhes_的博客
08-31 463
一个线程等待多个线程都在执行完毕，再继续自己的工作/*** 描述： 工厂中，质检，5个工人检查，所有人都认为通过，才通过// 5个等待线程 ExecutorService service = Executors . newFixedThreadPool(5);i < 5;i ++) {try {System . out . println("No." + no + "完成了检查。");// 每个线程休眠后，会进行一次计数 } } };...
第十一章——并发控制
Miss Z的博客
02-26 4338
数据库是一个共享资源，可以供多个用户使用。允许多个用户同时使用同一个数据库的数据库系统称为多用户数据库系统 事务可以一个一个地串行执行，即每个时刻只有一个事务运行，其他事务必须等到这个事务结束以后方能运行。事务在执行过程中需要不同的资源，有时需要CPU，有时需要存取数据库，有时需要I/O，有时需要通信。如果事务串行执行，则许多系统资源将处于空闲状态。因此，为了充分利用系统资源，发挥数据库共享资源的特点，应该允许多个事务并行地执行。 在单处理机系统中，事务的并行执行实际上是这些并行事务的并行操作轮流交叉运行.
Twisted.Protocols并发编程：深入理解多线程与异步IO的6大策略
Twisted是一个事件驱动的网络框架，它允许开发者以非阻塞的方式处理IO操作，从而在单个线程中实现高并发。本章将对Twisted.Protocols并发编程进行概述，介绍其基本原理和优势。 ## 1.1 并发编程的基本概念 在深入...
JArray多线程处理：提升数据处理并发能力的7大策略
!...# 1. JArray多线程处理概述 在现代软件开发中，多线程处理已成为提升应用...本章将概述JArray在多线程环境中的应用，为后续深入探讨优化策略和并发模型打下基础。 在多线程编程中，我们需要关注的核心问题包括线程
【并发编程】：Python面试题深入剖析，多线程不再难
[【并发编程】：Python面试题深入剖析，多线程不再难](https://img-blog.csdnimg.cn/279983989d664e1da04231695220ae46.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA56...
Java多线程详解
weixin_44530708的博客
02-10 1355
java多线程问题分析与共享
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值