【JUC并发工具类与相关的应用场景详解】

最新推荐文章于 2023-10-13 23:52:27 发布
最新推荐文章于 2023-10-13 23:52:27 发布
阅读量131 收藏
点赞数
分类专栏： 并发专栏 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42070243/article/details/133500984
版权

文章目录

一、 并发操作工具类—ReentrantLock

1.1、什么是ReentrantLock

ReentrantLock是一种可重入的独占锁，允许同一个线程多次获取同一个锁而不被阻塞，同synchronized一样，是一种互斥锁，但是相对synchronized来说，ReentrantLock有以下特点：

  1. 可中断
  2. 可以设置超时时间
  3. 公平锁与非公平锁的切换
  4. 支持多个条件变量
  5. 与synchronized一样，支持可重入

如下图：
在这里插入图片描述

在多个线程同时操作同一个资源时，ReentrantLock相当于是给这些线程加了一道门锁，每个线程想要获取到资源，都需要先获取到这把钥匙，才能访问门锁后面持有的资源

1.2、ReentrantLock常用的API

ReentrantLock实现了Lock接口规范，常见的API如下：

  • void lock()：当前线程调用该方法获取锁；
lock.lock();//加锁
try{
	//业务代码
	....
} finally {
	lock.unlock();//解锁
}
  • void lockInterruptibly() throws InterruptedException：可中断的获取锁，和lock()方法不同点在于，该方法会响应中断，也就是在锁的获取过程中可以中断当前获取锁的线程；
  • boolean tryLock()：尝试非阻塞的获取锁资源，如果能获取到，返回true，否则返回false；
  • boolean tryLock(long time, TimeUnit unit) throws InterruptedException：设置超时时间尝试的获取锁资源，如果当前线程在超时时间之前能获取锁，就会返回true，反之返回false；
if(lock.trylock(1, TimeUnit.SECONDS)){//尝试加锁
	try{
		//业务代码
		....
	} finally {
		lock.unlock();//解锁
	}
}
  • void unlock()：释放当前线程锁资源；
  • Condition newCondition()：获取到等待/通知组件，该组件和当前的线程持有的锁进行绑定，当前的线程只有获取到锁，才能调用该组件的await()方法，而且调用后，当前线程将会把持有的锁资源释放掉；
package com.practice.juc;

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

public class ReentrantLockConditionTest {

    public static void main(String[] args) {
        //创建队列
        Queue queue = new Queue(10);
        //启动生产者线程
        new Thread(new Producer(queue)).start();
        //启动消费者线程
        new Thread(new Customer(queue)).start();

    }

    /**
     * 队列的定义
     */
    static class Queue{
        //元素数组
        private Object[] items;
        //数组长度大小
        int size = 0;

        //出队指针
        int takeIndex;

        //入队指针
        int putIndex;

        private ReentrantLock lock; //锁资源

        public Condition emptyCondition;//生产者阻塞时，如果当前队列为空，唤醒生产者线程

        public Condition fullCondition;//消费者者阻塞时，如果当前队列满了，唤醒消费者线程

        public Queue(int capacity){
            this.items = new Object[capacity];
            lock = new ReentrantLock();
            emptyCondition = lock.newCondition();
            fullCondition = lock.newCondition();
        }


        /**
         * 向队列中添加元素=>入队
         * @param value 添加的元素
         * @throws Exception
         */
        public void put(Object value) throws Exception{
            //加锁
            lock.lock();
            try{
                //如果当前使用的长度达到队列的长度，就需阻塞生产者线程
                while(size == items.length){
                    fullCondition.await();
                }
                //往队列中添加元素
                items[putIndex] = value;
                //如果是当前队列的下标达到了队列的长度，那就将当前下标置为0
                if(++putIndex == items.length){
                    putIndex = 0;
                }
                //当前长度加1并且唤醒消费者线程
                size ++;
                emptyCondition.signal();
            }finally {
                System.out.println("producer生产："+value);
                lock.unlock();
            }

        }
        /**
         * 队列中出队
         * @throws Exception
         */
        public Object take() throws Exception{
            //加锁
            lock.lock();
            try{
                //如果当前的队列为空的话，就需要阻塞当前消费者线程
                while(size == 0){
                    emptyCondition.await();
                }
                Object value  = items[takeIndex];

                items[takeIndex] = null;
                if(++takeIndex == items.length){
                    takeIndex = 0;
                }

                size --;
                fullCondition.signal();//消费完之后，唤醒生产者生产消息
                return value;
            }finally {
                lock.unlock();
            }

        }
        }
    }

/**
 * 生产者
 */
class Producer implements Runnable{

        /**
         * 生产队列
         */
        private ReentrantLockConditionTest.Queue queue;

        public Producer(ReentrantLockConditionTest.Queue queue){
            this.queue = queue;
        }
        @Override
        public void run() {
            try {
                //每个1秒轮询的生产一次
                while(true){
                    Thread.sleep(1000);
                    queue.put(new Random().nextInt());
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

    class Customer implements Runnable{

        /**
         * 消费队列
         */
        private ReentrantLockConditionTest.Queue queue;

        public Customer(ReentrantLockConditionTest.Queue queue){
            this.queue = queue;
        }
        @Override
        public void run() {
            try {
                while(true){
                    //每个2秒轮询的消费一次
                    Thread.sleep(2000);
                    System.out.println("customer消费消费消息："+ queue.take());
                }

            }catch (Exception e){
                e.printStackTrace();
            }

        }
    }

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

1.3、ReentrantLock的使用

在使用前我们需要注意4个问题：
1、默认情况下，ReentrantLock是非公平锁，在声明ReentrantLock()时，可以设置其参数为true=>就为公平锁；
2、因为ReentrantLock是可重入锁，所以当前线程的加锁次数和释放锁的次数要一致，否则就会导致线程阻塞或是程序异常；
3、加锁操作一定要放到try语句块代码之前，可以避免未加锁成功又释放锁的异常；
4、锁释放一定要放到finally中，不然会导致线程阻塞（程序出现异常情况也需要释放锁）

例如：抢票程序如下示例

package com.practice.juc;

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockTest {

    private final ReentrantLock lock = new ReentrantLock();//默认是非公平锁，ReentrantLock(true)为公平锁
    private static int tickets = 8;//能卖的票总数

    /**
     * 买票操作
     */
    public void buyTicket() {
        lock.lock();//对资源加锁
        try {
            if(tickets > 0){ //买票前判断是否还有余票
                try {
                    System.out.println(Thread.currentThread().getName()+"=>买票成功~~~"+",购买了第"+tickets+"张票");
                    Thread.sleep(10);
                }catch (Exception e){
                    e.printStackTrace();
                }

            }else {
                System.out.println("票卖完了~~~"+Thread.currentThread().getName()+"抢票失败~");
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        finally {
            lock.unlock();//释放锁
        }
    }

    /**
     * 测试并发买票
     * @param args
     */
    public static void main(String[] args) {
        ReentrantLockTest reentrantLockTest = new ReentrantLockTest();

        //模拟10个线程进行买8张票
        for (int i = 0; i < 11; i++) {
            Thread thread = new Thread(()->{
                reentrantLockTest.buyTicket();//进行抢票
            },"线程"+i);
            thread.start(); //启动线程
        }

        try{
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("剩余票数为："+tickets);
    }
}

程序运行结果为：
在这里插入图片描述

1.4、公平锁与非公平锁

ReentrantLock可支持公平锁与非公平锁两种方式：
公平锁：线程在获取锁时，按照等待的先后顺序进行排队获取锁；
非公平锁：线程在获取锁时，不按照等待的先后顺序获取锁，而是随机获取锁，ReentrantLock默认是非公平锁；
如下：

  private final ReentrantLock lock = new ReentrantLock();//默认是非公平锁
  private final ReentrantLock lock = new ReentrantLock(true);//更该参数为true该为：公平锁

如下图示：
在这里插入图片描述

在这里插入图片描述

1.5、可重入锁

可重入锁又称为递归锁，是指在同一个线程在外层方法获取锁的时候，再用该线程的内层方法自动获取锁，不会因为之前已经获取过还没释放锁而阻塞，在一定程度上可避免死锁问题，如下图示：

package com.practice.juc;

import java.util.concurrent.locks.ReentrantLock;

public class RecursionTest {

    private final ReentrantLock lock = new ReentrantLock();

    /**
     * 递归调用方法
     * @param callNum
     */
    public void recursionCall(int callNum){
        lock.lock();
        try{
            if(callNum == 0){
                return;
            }
            System.out.println("递归执行，callNum="+callNum);
            //递归调用方法
            recursionCall(callNum - 1);
        }finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        RecursionTest recursionTest = new RecursionTest();
        recursionTest.recursionCall(10);
    }
}

运行结果如下图：
在这里插入图片描述

1.6、ReentrantLock的应用场景

  1. 解决多线程竞争资源的问题，例如多线程同时队同一个数据进行写操作；
  2. 实现多线程任务顺序执行
  3. 实现等待/通知机制

二、 并发操作工具类—Semaphore

2.1、什么是Semaphore

Semaphore主要是通过信号量的方式来控制访问资源的线程，具体的过程如下图：
在这里插入图片描述

2.2、Semaphore常用的API

在Semaphore类中的构造器为：
在这里插入图片描述

在声明这个Semaphore时，其中的permits表示许可数，fair表示线程竞争的公平性

其中在这个类中，包含了如下的常用方法：

  • acquire()，表示阻塞并获取许可
  • tryAcquire()，表示在没有获取到许可情况下没返回false
  • release()，释放许可

2.3、Semaphore的使用

如下示例：

package com.practice.juc;

import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;


public class SemaphoreTest {

    /**
     * 同一时刻最多只允许有两个并发
     */
    private static Semaphore semaphore = new Semaphore(2);

    private static Executor executor = Executors.newFixedThreadPool(10);

    public static void main(String[] args) {
        for(int i=0;i<10;i++){
            executor.execute(()->getProductInfo2());
        }
    }

    public static String getProductInfo() {
        try {
            semaphore.acquire();
            System.out.println("请求服务");
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }finally {
            semaphore.release();
        }
        return "返回商品详情信息";
    }

    public static String getProductInfo2() {

        if(!semaphore.tryAcquire()){
            System.out.println("请求被流控了");
            return "请求被流控了";
        }
        try {
            System.out.println("请求服务");
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }finally {
            semaphore.release();
        }
        return "返回商品详情信息";
    }
}

2.4、Semaphore的应用场景

  1. 限流：Semaphore可以用于限制对共享资源的并发访问数量，以控制系统的流量
  2. 资源池：Semaphore可以用于实现资源池，以维护一组有限的共享资源

三、 并发操作工具类—CountDownLatch

3.1、什么是CountDownLatch

CountDownLatch是一个同步协助类，允许一个或多个线程等待，直到全部线程完成操作后才能结束：
在这里插入图片描述
CountDownLatch使用给定的计数值（count）初始化。await方法会阻塞直到当前的计数值（count），由于countDown方法的调用达到0，count为0之后所有等待的线程都会被释放，并且随后对await方法的调用都会立即返回。这是一个一次性现象 —— count不会被重置

3.2、CountDownLatch常用的API

  1. public void await() throws InterruptedException：调用 await() 方法的线程会被挂起，它会等待直到 count 值为 0 才继续执行
  2. public boolean await(long timeout, TimeUnit unit) throws InterruptedException： 和 await() 类似，若等待 timeout 时长后，count 值还是没有变为 0，不再等待，继续执行
  3. public void countDown()：会将 count 减 1，直至为 0

3.3、CountDownLatch的使用

如下示例：

package com.practice.juc;

import java.util.concurrent.CountDownLatch;

public class CountDownLatchTest {

    // begin 代表裁判 初始为 1
    private static CountDownLatch begin = new CountDownLatch(1);

    // end 代表玩家 初始为 8
    private static CountDownLatch end = new CountDownLatch(8);

    public static void main(String[] args) throws InterruptedException {

        for (int i = 1; i <= 8; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    // 预备状态
                    System.out.println("参赛者"+Thread.currentThread().getName()+ "已经准备好了");
                    // 等待裁判吹哨
                    try {
                        begin.await();
                    // 开始跑步
                    System.out.println("参赛者"+Thread.currentThread().getName() + "开始跑步");
                    Thread.sleep(1000);
                    // 跑步结束, 跑完了
                    System.out.println("参赛者"+Thread.currentThread().getName()+ "到达终点");
                    // 跑到终点, 计数器就减一
                    end.countDown();

                    }catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }).start();
        }
        // 等待 5s 就开始吹哨
        Thread.sleep(5000);
        System.out.println("开始比赛");
        // 裁判吹哨, 计数器减一
        begin.countDown();
        // 等待所有玩家到达终点
        end.await();
        System.out.println("比赛结束");

    }
}

3.4、CountDownLatch的应用场景

  1. 并行任务同步：CountDownLatch可以用于协调多个并行任务的完成情况，确保所有任务都完成后再继续执行下一步操作
  2. 多任务汇总：CountDownLatch可以用于统计多个线程的完成情况，以确定所有线程都已完成工作
  3. 资源初始化：CountDownLatch可以用于等待资源的初始化完成，以便在资源初始化完成后开始使用
三河与木
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JUC工具类的使用
BingzangAiyuzi的博客
06-11 319
JUC工具类的使用 简介 JUC指的是java.util.concurrent包下的工具类的简称，在jdk1.5时开始出现。 常用工具类 CountdownLatch CyclicBarrier Semaphore Exchanger 3.工具类的使用 CountdownLatch CountdownLatch的构造方法初始化时会给定一个固定的计数值大小，之后每次调用对象的countdown方法后该值都会减一，当这个值不是0的话，调用对象的await方法会一直阻塞下面的方法，直到为0。 使
JUC并发工具类的应用场景详解
Myname_China的博客
02-04 893
jdk提供了比synchronized更加高级的各种同步工具，包括ReentrantLock、Semaphore、CountDownLatch、CyclicBarrier等，可以实现更加丰富的多线程操作。
JUC常用工具类简单使用
蓝天的博客
06-09 425
1 ReentrantLock ReentrantLock是一个互斥锁，也是一个可重入锁。ReentrantLock锁在同一个时间点只能被一个线程锁持有，但是它可以被同一个线程多次获取，每获取一次AQS的state就加1，每释放一次state就减1。还记得synchronized嘛，它也是可重入的，一个同步方法调用另外一个同步方法是没有问题的。 在使用上无非就是获取锁和释放锁，我们完全可以用它来实现synchronized的功能。 实现synchronized功能 1.1ReentrantLock和
JUC并发编程的三个常用工具类使用
苏渠的博客
07-28 811
JUC并发包下有四个并发工具类，闭锁CountDownlatch、栅栏CyclicBarrier、信号量Semaphore、交换器Exchanger。 本篇文章我们对前三个辅助类进行讲解。 CyclicBarrier有两个构造器CyclicBarrier(int parties) ：创建一个CyclicBarrier对象，并指定其partiesCyclicBarrier(int parties, Runnable barrierAction) ：指定parties，并且执行其callBack(在所有线程都到
JUC 常用并发工具类教程（包括可重入锁ReentrantLock、CountDownLatch、读写锁ReadWriteLock、信号量Semaphore、常见队列等）
tttalk的博客
09-28 966
juc 多线程 重入锁ReentrantLock、CountDownLatch、读写锁ReadWriteLock、信号量Semaphore、常见队列
06、JUC并发工具类在大厂的应用场景详解-ev
最新发布
03-07
06、JUC并发工具类在大厂的应用场景详解_ev06、JUC并发工具类在大厂的应用场景详解_ev06、JUC并发工具类在大厂的应用场景详解_ev06、JUC并发工具类在大厂的应用场景详解_ev06、JUC并发工具类在大厂的应用场景详解_ev...
6、JUC并发工具类在大厂的应用场景详解(1).pdf
02-28
6.JUC并发工具类在大厂的应用场景详解 (1).pdf 7、深入理解 AQS 独占锁之 Reentrantlock 源码分析 (1).pdf 8、读写锁ReentrantReadWriteLock&StampLock详解.pdf 9、并发容器 (Map、List、Set） 实战及其原理.pdf 10...
juc详解juc详解juc详解juc详解juc详解juc详解juc详解
08-02
Java并发编程库（Java Util Concurrency，简称JUC）是Java平台中用于高效并发处理的重要工具包，包含在`java.util....在实际应用中，根据具体情况选择合适的并发工具，可以显著提高程序的并发性能和可维护性。
JUC并发编程.md
01-28
JUC（Java Util Concurrency）是Java标准库中的一个子包，提供了一系列高级并发工具类和接口，旨在简化多线程编程的复杂性。它包括了各种锁机制、线程池、信号量、屏障等实用组件，为开发人员提供了构建高性能并发...
Java 多线程与并发(13-26)-JUC集合- ConcurrentHashMap详解.pdf
07-26
【Java 多线程与并发】并发集合类`ConcurrentHashMap`是Java程序设计中一个重要的工具，尤其在高并发场景下，它提供了高效的线程安全。`ConcurrentHashMap`在JDK 1.7和1.8中有着显著的区别。 在JDK 1.7中，`...
一文+图解！搞明白并发工具JUC的使用
欢迎来到我的博客
09-12 180
全称是 AbstractQueuedSynchronizer，是阻塞式锁和相关的同步器工具的框架tryAcquire （尝试获取锁）tryRelease （尝试解开锁）tryAcquireShared （尝试获得共享锁）tryReleaseShared （尝试解开共享锁）isHeldExclusively（判断是否是当前线程，用于实现可重入锁）用 state 属性来表示资源的状态（分独占模式和共享模式），子类需要定义如何维护这个状态，控制如何获取锁和释放锁。
JUC常用并发工具类
zhaolk的博客
04-04 481
四个案例带你彻底搞懂java最常见的并发工具类，semaphore，countdownlatch，exchanger，cyclicbarrier。
Java 并发包(JUC多线程)下面的工具类，在实际工作中都有哪些应用场景呢？
Java后端技术栈
11-09 808
下面可以主要分几类： 1. 线程间通信工具类，如Semaphore ,、CountDownLatch、Future等等，这种也经常用，特别是在写多线程高并发的程序时，结合通信工具和锁把线程编排的符合你的预期执行 2. 锁，JUC提供了各种在某些场景下比synchronized更合适的高级锁实现，包括读写锁，互斥锁等等，因其多数基于CAS这种乐观锁实现，性能一般要由于synchronized内置锁，而且结合Cdondition更灵活可控。 不过个人觉得，这些锁除了jdk以及一些知名框架中使用外，我们日常工
并发编程-JUC并发工具类应用场景详解
weixin_43874650的博客
10-13 75
ReentrantLock具体应用场景如下：1. 解决多线程竞争资源的问题，例如多个线程同时对同一个数据库进行写操作，可以使用ReentrantLock保证每次 只有一个线程能够写入。2. 实现多线程任务的顺序执行，例如在一个线程执行完某个任务后，再让另一个线程执行任务。3. 实现多线程等待/通知机制，例如在某个线程执行完某个任务后，通知其他线程继续执行任务。
JUC实战必备-全是精华
weixin_43206491的博客
11-22 800
????JUC 简介 JAVA 在 1.5版本中引入了 java.util.concurrent工具包，JUC 就是它的简称，用于处理线程的工具包。 ????重温进程与线程 进程：指在系统中正在运行的一个应用程序；程序一旦运行就是进程；进程——资源分配的最小单位。 线程：系统分配处理器时间资源的基本单元，或者说进程之内独立执行的一个单元执行流。线程——程序执行的最小单位。 线程的状态 NEW：新建 RUNNABLE：准备就绪 BLOCKED：阻塞 WAITING：等待（不见不散） TIMED_WAITIN
源码解析：JUC及使用场景
yilvi的博客
02-28 1362
本文当用于帮助读者从功能性上理解JUC的功能场景 * 阅读之前请先确定了解集合相关的基础知识 * 一、Collections工具类 该类应用工厂及静态内部类的形式为已有数据结构进行加工，赋予dynamically(checked) 、empty 、immutable(singleton) 、synchronized.所有读写都加对象锁、unmodifiable view(unmodifiable).final修饰对象，写操作throw new UnsupportedOperationException.
JUC中几个常见的并发工具类详解
romantic_jie的博客
08-30 1914
在JDK的并发包里提供了几个非常有用的并发工具类。 其中CountDownLatch,CyclicBarrier和Semaphore工具类提供了一种并发控制的手段。 而Exchanger工具类则提供了在线程间进行交换数据的一种手段。 1.等待多线程完成的CountDownLatch CountDownLatch允许一个或多个线程等待其他线程完成操作。 定义抽象难理解，直接上测试代码！ ...
JUC包下的几个辅助类
qq_32302897的博客
08-14 1416
1、semaphore Semaphore中文解释成信号量的意思，可以看成一个可获数量有限的共享锁。锁只可被有限数量线程使用。 这个辅助类的核心方法是acquire以及release方法。acquire方法用于获取许可，release用于归还一个许可。 acquire方法其默认调用的是非公平的获取方法。意思也就是每当执行一次这个acquire方法，便会将你指定的avaliable(你指定的数...
JUC五种常见同步工具类总结
luoyoub的博客
06-09 5876
JUC常用工具类 Semaphore CountDownLatch CyclicBarrier Exchanger Phaser 使用场景 这五种同步辅助类适用于的同步场景： Semaphore 信号量是一类经典的同步工具。信号量通常用来限制线程可以同时访问的（物理或逻辑）资源数量。 CountDownLatch 一种非常简单、但很常用的同步辅助类。其作用是在完成一组正在其他线程中执...
Java并发编程详解：JUC工具包与多线程实战
狂神笔记和相应的视频课程为初学者提供了丰富的实践案例和深入讲解，有助于读者更好地理解和应用这些并发工具和概念，提升并发编程能力。在学习过程中，结合实际生活中的例子，可以使抽象的概念更加生动易懂，从而...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值