JUC中对线程的协同合作控制

最新推荐文章于 2024-04-26 22:58:12 发布
最新推荐文章于 2024-04-26 22:58:12 发布
阅读量288 收藏
点赞数
分类专栏： 多线程与并发编程 文章标签： 多线程 java 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a760352276/article/details/109783598
版权

线程的协同合作控制

在使用多线程的时候，我们可以使用一些工具来达到对资源的访问量控制、线程之间的相互等待、线程之间的通信唤醒。

控制线程的合作并发，主要有四大工具；CountDownLatch，Semaphore，Condition以及CyclicBarrier。下面对这四个工具进行逐一介绍。

CountDownLatch

CountDownLatch主要是用于线程之间的等待协作。可以实现多等一，也可以实现一等多。

例如，我们需要启动多个线程进行资源加载，等资源加载完成后主线程才能继续执行；这就可以用CountDownLatch的一等多的机制来完成；或者我们想自实现并发情况可以通过多等一的方式来使线程阻塞，等主线程经过一系列操作（休眠，或者准备其他资源）后，进行放行。

使用

CountDownLatch在构造的时候需要传入一个参数，这个参数就是需要等待线程的个数，并且提供了一个阻塞的方法await()来让线程进行阻塞，只有当等待数减为0的时候，被阻塞的线程才能往下执行。

而等待数可以通过CountDownLatch的countdown()来进行减一的操作。

代码演示

一等多代码示例：
可用于等待资源

public class CountDownLatchTest {

    // 构造一个倒数器
    static CountDownLatch countDownLatch = new CountDownLatch(2);
    public static void main(String[] args) throws InterruptedException {
        // 启动两个线程来加载资源
        new Thread(new TaskOne()).start();
        new Thread(new TaskTwo()).start();
        System.out.println("资源加载线程启动完成，Time:"+new SimpleDateFormat("hh:mm:ss").format(new Date()));
        countDownLatch.await();
        System.out.println("主线程执行完成,Time:"+new SimpleDateFormat("hh:mm:ss").format(new Date()));

    }
}

// 任务二
class TaskOne implements  Runnable{
    @Override
    public void run() {
        // 模拟处理资源要5秒
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("TaskOne Finish");
        // 完成工作，线程数减一
        CountDownLatchTest.countDownLatch.countDown();
    }
}

// 任务一
class TaskTwo implements  Runnable{
    @Override
    public void run() {
        // 模拟处理资源要10秒
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 完成工作，线程数减一
        CountDownLatchTest.countDownLatch.countDown();
        System.out.println("TaskTwo Finish");

    }
}

结果演示：
在这里插入图片描述
可以看到，主线程确实等待了子线程完成了对应的工作才能继续走下去。否则，会一直阻塞在当前状态下等待。

多等一代码示例：
可用于模拟并发的场景

public class CountDownLatchMuch {
    // 构造一个倒数器
    static CountDownLatch countDownLatch = new CountDownLatch(1);
    public static void main(String[] args) throws InterruptedException {
        // 用newCachedThreadPool 开多个任务线程（这里可以先了解一下JDK提供的线程池）
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 100 ; i++) {
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println("线程已到达 , Time:"+new SimpleDateFormat("hh:mm:ss").format(new Date()));
                        // 先让所有线程在这里阻塞
                        countDownLatch.await();
                        System.out.println("线程出发 , Time:"+new SimpleDateFormat("hh:mm:ss").format(new Date()));
                        //TODO 这里可以调用任意接口HttpClient来模拟高并发
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
        // 休眠5秒，让所有线程都准备好
        Thread.sleep(5000);
        // 放行所有的线程
        countDownLatch.countDown();
    }
}

执行结果：
在这里插入图片描述

我们可以看到，子线程在我们休眠五秒后，主线程调用countdown()方法，然后同一时间被放行的。

小结

CountDownLatch通过我们实现定义好的计数器，当我们达到某种条件后可让计数器-·；最终当计数器为0时，激活调用await()方法的线程进行下一步操作。

Semaphore

Semaphore可以简单的理解为许可证。

只有拿到对应数量许可证的人才能通行，其他拿不到对应数量的人统统会被阻塞住；并且，还要等别人释放了许可证，自己才有机会拿到。

这就好比，有一些大的资源要限制更少的人拿去，有一些较小的资源允许多人拿去，并且这两个资源共用一种许可证。

使用

Semaphore提供了许多方法可以使用：
在这里插入图片描述
常用的

  • acquire()：拿取一个许可证
  • acquire(int permits)：拿取permits个许可证
  • release()：释放一个许可证
  • release(int permits)：释放permits个许可证
  • tryAcquire()：尝试拿取一个许可证
  • tryAcquire(int permits)：尝试拿取permits个许可证
  • tryAcquire(long timeout, TimeUnit unit)：尝试在timeout unit 内拿取一个许可证；unit表示时间单位
  • tryAcquire(int permits, long timeout, TimeUnit unit)：尝试在timeout unit 内拿取permits个许可证
  • 带有try的获取许可证的方法都是尝试去拿，会立马返回布尔值类型的结果；而不带try的则会阻塞的等待别人释放，在去拿。

代码演示：

不释放许可证

public class SemaphoreOneTest {
    // 允许开放两个人去操作
    static Semaphore semaphore = new Semaphore(2);
    public static void main(String[] args) throws InterruptedException {
        new Thread(new SemaTaskOne()).start();
        new Thread(new SemaTaskTwo()).start();
        Thread.sleep(500);
        semaphore.acquire();
        System.out.println(Thread.currentThread().getName()+"拿到了许可证");
        System.out.println("Main Finish");
    }
}

class SemaTaskOne implements Runnable{

    @Override
    public void run() {
        try {
            SemaphoreOneTest.semaphore.acquire();
            System.out.println(Thread.currentThread().getName()+"拿到了许可证");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class SemaTaskTwo implements Runnable{

    @Override
    public void run() {
        try {
            SemaphoreOneTest.semaphore.acquire();
            System.out.println(Thread.currentThread().getName()+"拿到了许可证");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在这里插入图片描述
我们看到如果不释放许可证的话，即使子线程执行完，主线程仍然拿不到许可证；如果主线程有机会先拿到许可证，即使主线程执行完了，程序仍然处于运行状态。因为拿到许可证的线程都没有释放，仍有子线程处于阻塞状态。

增加释放：

class SemaTaskOne implements Runnable{
    @Override
    public void run() {
        try {
            SemaphoreOneTest.semaphore.acquire();
            System.out.println(Thread.currentThread().getName()+"拿到了许可证");
            Thread.sleep(5000);
            
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
       		SemaphoreOneTest.semaphore.release();
        }
    }
}

信号的释放必须放在finally块中，否则程序发生异常不会释放许可证。

正确释放许可证结果：
在这里插入图片描述

错误释放许可证结果：
在这里插入图片描述

带有参数的许可证演示：

public class SemaphoreOneTest {
    // 允许开放两个人去操作
    static Semaphore semaphore = new Semaphore(2);
    public static void main(String[] args) throws InterruptedException {
        new Thread(new SemaTaskOne()).start();
        new Thread(new SemaTaskTwo()).start();
        System.out.println(Thread.currentThread().getName()+"等待中,Time:"+new SimpleDateFormat("hh:mm:ss").format(new Date()));
        semaphore.acquire(2);
        System.out.println(Thread.currentThread().getName()+"拿到了许可证"+new SimpleDateFormat("hh:mm:ss").format(new Date()));
        Thread.sleep(4000);
        semaphore.release(2);
        System.out.println("Main Finish");
    }
}

class SemaTaskOne implements Runnable{
    @Override
    public void run() {
        try {
            System.out.println(Thread.currentThread().getName()+"等待中,Time:"+new SimpleDateFormat("hh:mm:ss").format(new Date()));
            SemaphoreOneTest.semaphore.acquire(2);
            System.out.println(Thread.currentThread().getName()+"拿到了许可证"+new SimpleDateFormat("hh:mm:ss").format(new Date()));
            Thread.sleep(4000);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            SemaphoreOneTest.semaphore.release(2);
        }
    }
}

class SemaTaskTwo implements Runnable{

    @Override
    public void run() {
        try {
            System.out.println(Thread.currentThread().getName()+"等待中,Time:"+new SimpleDateFormat("hh:mm:ss").format(new Date()));
            SemaphoreOneTest.semaphore.acquire(2);
            System.out.println(Thread.currentThread().getName()+"拿到了许可证"+new SimpleDateFormat("hh:mm:ss").format(new Date()));
            Thread.sleep(4000);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            SemaphoreOneTest.semaphore.release(2);
        }
    }
}

演示结果：
在这里插入图片描述

小结

非阻塞的尝试拿取就不做演示了，大体上差不多。只不过不会阻塞，也可以设置超时时间的拿，如果在这段时间拿不到的话线程就继续往下执行。

Semaphore在使用的过程中，一定要保证许可证能正确的释放，否则会出现死锁的问题导致程序无法运行下去。

Condition

Condition本质上是一个接口，所以只能实例化其子类或者根据需求重写对应的方法。

使用

其实跟Object的wait和notify方法类似，Condition提供了await()和signal()。在await()中提供了可设置超时时间的重载方法。

代码

下面用Condition来演示一个生产者和消费者模式


public class ConditionTest {

    static ReentrantLock reentrantLock = new ReentrantLock();
    // 生产者锁
    static Condition conditionProvier =  reentrantLock.newCondition();
    // 消费者锁
    static Condition conditionConsumer =  reentrantLock.newCondition();
    static Queue arrayList = new ArrayBlockingQueue(10);

    public static void main(String[] args) {

        new Thread(new ConditionTask()).start();
        new Thread(new ConditionTaskTwo()).start();
    }
}

// 消费者
class ConditionTask implements Runnable{
    @Override
    public void run() {
        while(true) {
            try {
                ConditionTest.reentrantLock.lock();
                if (ConditionTest.arrayList.size() <= 0) {
                    System.out.println("无了，先不拿");
                    ConditionTest.conditionConsumer.await();
                }
                int poll = (int) ConditionTest.arrayList.poll();
                System.out.println("弹出元素，" + poll);
                ConditionTest.conditionProvier.signalAll();
            } catch (Exception e) {
            } finally {
                ConditionTest.reentrantLock.unlock();
            }
        }
    }
}

// 生产者
class ConditionTaskTwo implements Runnable{
    int i = 0;
    @Override
    public void run() {
        while(true) {
            try {
                ConditionTest.reentrantLock.lock();
                //Thread.sleep((long) (Math.random() * 10000));
                if (ConditionTest.arrayList.size() >= 10) {
                    System.out.println("满了，暂停一下");
                    ConditionTest.conditionProvier.await();
                }
                System.out.println("插入元素");
                ConditionTest.arrayList.offer(i++);
                ConditionTest.conditionConsumer.signalAll();
            } catch (Exception e) {
            } finally {
                ConditionTest.reentrantLock.unlock();
            }
        }
    }
}

结果演示：
在这里插入图片描述

CyclicBarrier

CyclicBarrier比较容易理解，凑够了一拨人就出发。

使用：

  • 只需要要在构造参数中传入要凑够多少人（线程），具体线程调用await()方法，如果凑够了指定数的线程就一起出发。
  • 也可以传入凑够的人数和执行线程；这个执行线程是凑够人数后，await()线程会继续往下执行，当前线程开启执行线程，相当于多一个线程用于提醒或执行其他操作。
  • 后面凑不够指定的也会全部出发了

代码演示

无执行线程

public class CyclicBarrierOneTask {

    public static void main(String[] args) throws BrokenBarrierException, InterruptedException {
		// 一次凑够5个人出发
        CyclicBarrier cyclicBarrierWithOutRunnable = new CyclicBarrier(5);
		// 开10个线程
        for (int i = 0; i < 10; i++) {
            new Thread(new CyclicBarrierSmailTask(cyclicBarrierWithOutRunnable)).start();
        }
    }
}

class CyclicBarrierSmailTask implements Runnable{
    private  CyclicBarrier cyclicBarrier;

    public CyclicBarrierSmailTask(CyclicBarrier cyclicBarrier) {
        this.cyclicBarrier = cyclicBarrier;
    }

    @Override
    public void run() {
        try {
            // 让线程随机休眠，显示出先来后到的凑够一拨人
            long time = (long) (Math.random() * 10000);
            Thread.sleep(time);
            System.out.println(Thread.currentThread().getName()+"等待中");
            cyclicBarrier.await();
            System.out.println(Thread.currentThread().getName()+"出发了");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
    }
}

运行结果：

在这里插入图片描述

增加执行线程

public static void main(String[] args) throws BrokenBarrierException, InterruptedException {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(5,new Runnable(){
            @Override
            public void run() {
                System.out.println("凑够了一拨人，出发");
            }
        });
        for (int i = 0; i < 10; i++) {
            new Thread(new CyclicBarrierSmailTask(cyclicBarrier)).start();
        }
    }

结果演示：
在这里插入图片描述

当调用await()的线程数达到指定数时，就会出发执行线程。并且之前调用await()的线程会一起运行，不在阻塞。

小结

合理运用好线程控制工具可以很好的帮助我们使用线程的合作，如果需要搞懂内部原理的话需要对AQS进一步掌握。

因为里面的控制数就是通过AQS中的state类变量来计数。

矮萌杰;
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
多线程 - JUC
学无止境
04-02 456
Lock 接口及其实现类用于替代传统的 synchronized 关键字，提供更灵活的锁定机制，可以实现公平锁、非公平锁、可重入锁、读写锁等多种类型的锁。ConcurrentHashMap在内部采用了分段锁的机制，将整个哈希表分成了多个段（Segment），每个段都拥有自己的锁，不同的线程可以同时访问不同的段，这样就可以提高并发读取的效率。线程池是 Java 并发编程中的重要概念，可以通过 ThreadPoolExecutor 类来创建一个线程池，线程池可以管理一组线程，复用线程并控制并发执行的线程数量。
Qt QWaitConditon 实现生产者消费者 (源码)
09-10
用 QWaitConditon 实现生产者消费者，此为源代码。讲解文档见站内博客http://blog.csdn.net/qq_35488967/article/details/77923487
[Java] sleep 和 wait 的区别
weixin_30929011的博客
09-09 104
对于sleep()方法，我们首先要知道该方法是属于Thread类中的。而wait()方法，则是属于Object类中的。 sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。 在调用sleep()方法的过程中，线程不会释放对象锁。 而当调用wait()方法的时候，线程会放弃对象锁，进入等待此对象的等待锁定池，只...
多线程中的wait与sleep到底谁释放了锁
weixin_30425949的博客
02-01 544
首先，多线程中会使用到两个延迟的函数，wait和sleep。wait是Object类中的方法，而sleep是Thread类中的方法。 sleep是Thread类中的静态方法。无论是在a线程中调用b的sleep方法，还是b线程中调用a的sleep方法，谁调用，谁睡觉。最主要的是sleep方法调用之后，并没有释放锁。使得线程仍然可以同步控制。sleep不会让出系统资源；而wait是进入线程等待...
qt非thread使用sleep_面试官：同样是等待，sleep和wait有哪些区别
weixin_39889792的博客
12-02 211
如何答？基本的差别sleep是Thread类的方法，wait是Object类的方法sleep方法可以在任何地方使用，wait只能在synchronized方法或synchronized块中使用最主要的本质区别Thread.sleep只会让出CPU，不会释放对象锁Object.wait不仅让出CPU，还会释放对象锁。只有针对此对象调用notify()方法或者时间到了，才能再次执行代码演示去掉了try...
线程控制juc并发
hollow_0120的博客
06-04 114
减法计数器 //总数6 计数器 减法计数器 CountDownLatch countDownLatch = new CountDownLatch(6); //-1 countDownLatch.countDown(); //等待计数器归0 才向下执行 countDownLatch.await(); //这样是输出不了的 必须等待计数器为0 System.err.println("xixi
JUC线程锁框架
12-31
CountDownLatch、CyclicBarrier、Semaphore等同步器在多线程协同工作中起到关键作用。CountDownLatch用于一次性释放多个等待线程，CyclicBarrier则让一组线程等待直到所有线程到达屏障点，Semaphore则控制对共享...
多线程之JUC
m0_57698935的博客
09-27 508
多线程之JUC 1、什么是JUC？ JUC是java.util.concurrent的简写 在jdk官方手册中可以看到JUC相关的jar包有三个。 JUC的意思就是java并发编程工具包 并发编程的本质就是充分利用CPU资源 进程、线程 进程 进程是指在系统中正在运行的一个应用程序，程序一旦运行就是进程。 进程是系统进行资源分配的独立实体， 且每个进程拥有独立的地址空间。 一个进程可以拥有多个线程，每个线程使用其所属进程的栈空间。 线程 线程是进程的一个实体，是进程的一条执行路径。 线程是CPU独立运行和独
【Java之多线程】JUC常见知识点全面总结_juc 考点
最新发布
2401_84618023的博客
04-26 761
大部分情况下使用就足够了锁竞争激烈的时候，使用, 搭配trylock方法可以更灵活地控制加锁的行为，而不是死等。如果需要使用公平锁, 使用信号量Semaphore一般用来表示可用资源的个数，相当于一个计数器，可类比生活中停车场牌子上面显示的停车场剩余车位数量。当有车开进去的时候, 就相当于申请一个可用资源，可用车位就 -1 (这个称为信号量的 P 操作)当有车开出来的时候, 就相当于释放一个可用资源, 可用车位就 +1 (这个称为信号量的 V 操作)
JAVA线程高级-线程按序交替执行
11-01
然而，在某些场景下，我们可能需要控制线程的执行顺序，确保它们按照特定的顺序交替运行，这在并发编程中被称为线程同步或线程协调。Java提供了一些高级特性来实现这样的需求，比如`Thread`类、`synchronized`关键字...
JUC多线程并发控制类--CountDownLatch
shjdwld的专栏
11-02 101
import java.util.concurrent.*; public class CountDownLatchDemo { public static void main(String[] args) { ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(3, 3, 30, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(4), E.
JUC，自己实现简单的控制线程数
u010321010的博客
04-28 112
遇到的一个笔试，做个记录，（让你只实现handle方法内容，来控制访问doHandle方法最多只有3个线程数）， 如果不是定好只能在handle方法实现， 可以用线程池，或者Semaphore（信号量）来控制执行的线程数 /** 初始化一个信号量为3，默认是false 非公平锁， 模拟3个停车位 */ //这个要全局，题目没有给，所以没法用这个方法 Semaphore semaphore = new Semaphore(3, false); //下面是handle里面的方法 semaphore.acqu
JUC学习笔记（三）Lock API控制多线程
slxysyka的博客
03-08 371
Lock接口，可重入锁，读写锁，线程间通信，Lock与synchronize的对比
qt非thread使用sleep_多线程必会基础，sleep和wait的区别
weixin_31000553的博客
12-02 357
本文为小编原创文章，首发于Java识堂，一个高原创，高收藏，有干货的微信公众号，一起成长，一起进步，欢迎关注介绍基本的差别sleep是Thread类的方法，wati是Object类的方法sleep方法可以在任何地方使用wait只能在synchronized方法或synchronized块中使用最主要的本质区别Thread.sleep只会让出CPU，不会导致锁行为的改变Object.wait不仅让出...
JUC——线程池(底层原理、手写线程池)
guochaoHNU的博客
08-19 364
目录为什么要使用线程池 为什么要使用线程池 工作原理：(控制运行的线程数量) 处理过程中将任务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了最大执行数量，超出数量的线程排队等候，等其他线程执行完毕，再从队列中取出任务来执行。 线程池的优势(为什么要使用线程池)： 1.降低资源消耗。通过重复利用已经创建的线程降低线程创建和销毁所造成的的消耗。（线程复用） 2.提高响应速度。当任务到达时，任务可以不需要等待线程创建就能够立即执行。 3.提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗
Java并发编程 - 线程
OneFine的技术博客
06-02 393
java线程基础知识回顾
Wait和Sleep异同
pp_lan的博客
03-23 233
相同点： 1. 都是用来将线程转为阻塞状态的 2. 都是可以被打断的（如：调用线程的interrupt方法），需要捕捉InterruptedException； 不同点： 1. 【来源】wait是Object的方法，sleep是Thread的一个静态方法； 2. 【核心】wait会释放monitor锁，让出cpu使用权，而sleep不会； 3. 【使用】wait需要在同步方法内使用，而...
Qt wait
neu_sunlei的专栏
09-17 1821
<br />void HttpSql::wait(int ms ) { QElapsedTimer timer; timer.start(); do { QCoreApplication::processEvents(QEventLoop::AllEvents, ms); ::Sleep(10); } while (timer.elapsed() < ms); }
QT中的wait、wakeOne、wakeAll的使用
ylxwk的博客
06-22 5525
对生产者和消费者问题的另一个解决办法是使用QWaitCondition，它允许线程在一定条件下唤醒其他线程。其中wakeOne()函数在条件满足时随机唤醒一个等待线程，而wakeAll()函数则在条件满足时唤醒所有等待线程。 1、boolwait(QMutex*mutex,unsignedlongtime = ULONG_MAX) 1) 释放锁定的mutex 2) 在线程对象上等待 mutex必须由调用线程进行初锁定 。注意调用wait的话，会自动调用unlock...
Java并发编程入门：理解JUC与多线程模型
在实践中，Java并发编程需要注意线程安全、同步控制（如锁机制、原子操作）、死锁、活锁和饥饿等问题。JUC库提供了丰富的工具来帮助开发者设计线程安全的数据结构和并发算法，降低并发编程的复杂性和出错可能性。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值