JUC并发工具类应用场景

已于 2023-07-30 20:23:15 修改
阅读量51 收藏
点赞数
分类专栏： 并发 文章标签： java
于 2023-07-29 13:19:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37174301/article/details/131988583
版权

常用并发同步工具类的真实应用场景

jdk提供了比synchronized更加高级的各种同步工具，包括ReentrantLock、Semaphore、CountDownLatch、CyclicBarrier等，可以实现更加丰富的多线程操作。
在这里插入图片描述

ReentrantLock

ReentrantLock是一种可重入的独占锁，它允许同一个线程多次获取同一个锁而不会被阻塞。
它的功能类似于synchronized是一种互斥锁，可以保证线程安全。相对于 synchronized， ReentrantLock具备如下特点：

  • 可中断
  • 可以设置超时时间
  • ==可以设置为公平锁 ==
  • 支持多个条件变量
  • 与 synchronized 一样，都支持可重入
    它的主要应用场景是在多线程环境下对共享资源进行独占式访问，以保证数据的一致性和安全性。
    在这里插入图片描述
    在这里插入图片描述

常用API

Lock接口
接口解释
void lock()获取锁，调用该方法当前线程会获取锁，当锁获得后，该方法返回
void lockInterruptibly() throws InterruptedException可中断的获取锁，和lock()方法不同之处在于该方法会响应中断，即在锁的获取中可以中断当前线程
boolean tryLock()尝试非阻塞的获取锁，调用该方法后立即返回。如果能够获取到返回true，否则返回false
boolean tryLock(long time, TimeUnit unit) throws InterruptedException超时获取锁，当前线程在以下三种情况下会被返回: 1，当前线程在超时时间内获取了锁 2，当前线程在超时时间内被中断 3，超时时间结束，返回false
void unlock()释放锁
Condition newCondition()获取等待通知组件，该组件和当前的锁绑定，当前线程只有获取了锁，才能调用该组件的await()方法，而调用后，当前线程将释放锁
基本语法
//加锁  阻塞 
lock.lock(); 
try {  
    ...
} finally { 
    // 解锁 
    lock.unlock();  
}


//尝试加锁   非阻塞
if (lock.tryLock(1, TimeUnit.SECONDS)) {
    try {
        ...
    } finally {
        lock.unlock();
    }
}

在使用时要注意 4 个问题：

  1. 默认情况下 ReentrantLock 为非公平锁而非公平锁;
  2. 加锁次数和释放锁次数一定要保持一致，否则会导致线程阻塞或程序异常;
  3. 加锁操作一定要放在 try 代码之前，这样可以避免未加锁成功又释放锁的异常
  4. 释放锁一定要放在 finally 中，否则会导致线程阻塞。

ReentrantLock使用

独占锁：模拟抢票场景
package cn.wang.testsync;

import java.util.concurrent.locks.ReentrantLock;

/**
 * 模拟抢票场景
 */
public class ReentrantLockDemo {
    //默认非公平锁
    private final ReentrantLock lock = new ReentrantLock();
    //总票数
    private static int tickets = 8;

    public void buyTicket(){
        //获取锁
        lock.lock();
        try {
            if (tickets >0){
                try {
                    Thread.sleep(10);//休眠10ms，模拟出并发效果
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "购买了第" + tickets-- + "张票");
            }else{
                System.out.println("票已经卖完了，" + Thread.currentThread().getName() + "抢票失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }



    }

    public static void main(String[] args) {
        ReentrantLockDemo reentrantLockDemo = new ReentrantLockDemo();
        for (int i = 0; i <= 10 ; i++) {
            Thread thread = new Thread(()->{
                //抢票
                reentrantLockDemo.buyTicket();
            },"线程"+i);
            thread.start();

        }

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("剩余票数"+tickets);
    }
}

不加锁的效果，出现超卖问题
在这里插入图片描述
加锁效果： 正常，两个人抢票失败
在这里插入图片描述

公平锁和非公平锁

ReentrantLock支持公平锁和非公平锁两种模式：

  • 公平锁：线程在获取锁时，按照等待的先后顺序获取锁。
  • 非公平锁：线程在获取锁时，不按照等待的先后顺序获取锁，而是随机获取锁。ReentrantLock默认是非公平锁
ReentrantLock lock = new ReentrantLock(); //参数默认false，不公平锁  
ReentrantLock lock = new ReentrantLock(true); //公平锁

比如买票的时候就有可能出现插队的场景，允许插队就是非公平锁，如下图：
在这里插入图片描述

可重入锁

可重入锁又名递归锁，是指在同一个线程在外层方法获取锁的时候，再进入该线程的内层方法会自动获取锁（前提锁对象得是同一个对象），不会因为之前已经获取过还没释放而阻塞。Java中ReentrantLock和synchronized都是可重入锁，可重入锁的一个优点是可一定程度避免死锁。在实际开发中，可重入锁常常应用于递归操作、调用同一个类中的其他方法、锁嵌套等场景中。

class Counter {
    private final ReentrantLock lock = new ReentrantLock(); // 创建 ReentrantLock 对象

    public void recursiveCall(int num) {
        lock.lock(); // 获取锁
        try {
            if (num == 0) {
                return;
            }
            System.out.println("执行递归，num = " + num);
            recursiveCall(num - 1);
        } finally {
            lock.unlock(); // 释放锁
        }
    }
    
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter(); // 创建计数器对象

        // 测试递归调用
        counter.recursiveCall(10);
    }
}
结合Condition实现生产者消费者模式

java.util.concurrent类库中提供Condition类来实现线程之间的协调。调用Condition.await() 方法使线程等待，其他线程调用Condition.signal() 或 Condition.signalAll() 方法唤醒等待的线程。
注意：调用Condition的await()和signal()方法，都必须在lock保护之内。
案例：基于ReentrantLock和Condition实现一个简单队列

package cn.wang.testsync;


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

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

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

    private Queue queue;

    public Producer(Queue queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        try {
            // 隔1秒轮询生产一次
            while (true) {
                Thread.sleep(1000);
                queue.put(new Random().nextInt(1000));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
class Queue{
    private Object[] items;
    int size = 0;
    int takeIndex;
    int putIndex;
    private ReentrantLock lock;
    //消费者线程阻塞唤醒条件，队列为空阻塞，生产者生产完唤醒
    public Condition notEmpty;
    //生产者线程阻塞唤醒条件，队列满了阻塞，消费者消费完唤醒
    public Condition notFull;

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

    public void put(Object value){
        lock.lock();
        try {
            while (size == items.length){
                // 队列满了让生产者等待
                notFull.await();
            }
            items[putIndex]= value;
            if (++putIndex == items.length){
                putIndex = 0;
            }
            size++;
            notEmpty.signal();//生产完唤醒线程
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
            System.out.println("producer生产：" + value);

        }


    }

    public Object take() throws InterruptedException {
        lock.lock();
        try {
            //队列空了就让消费者等待
            while(size == 0){
                notEmpty.await();
            }
            Object value = items[takeIndex];
            items[takeIndex] = null;
            if (++takeIndex == items.length){
                takeIndex = 0;
            }
            size--;
            notFull.signal(); //消费完唤醒生产者生产
            return value;


        } finally {
            lock.unlock();

        }
    }
}
class Customer implements Runnable {

    private Queue queue;

    public Customer(Queue queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        try {
            // 隔2秒轮询消费一次
            while (true) {
                Thread.sleep(2000);
                System.out.println("consumer消费：" + queue.take());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

应用场景总结

ReentrantLock具体应用场景如下：

  • 解决多线程竞争资源的问题，例如多个线程同时对同一个数据库进行写操作，可以使用ReentrantLock保证每次只有一个线程能够写入。
  • 实现多线程任务的顺序执行，例如在一个线程执行完某个任务后，再让另一个线程执行任务。
  • 实现多线程等待/通知机制，例如在某个线程执行完某个任务后，通知其他线程继续执行任务。

Semaphore

Semaphore（信号量）是一种用于多线程编程的同步工具，用于控制同时访问某个资源的线程数量。
在这里插入图片描述
Semaphore维护了一个计数器，线程可以通过调用acquire()方法来获取Semaphore中的许可证，当计数器为0时，调用acquire()的线程将被阻塞，直到有其他线程释放许可证；线程可以通过调用release()方法来释放Semaphore中的许可证，这会使Semaphore中的计数器增加，从而允许更多的线程访问共享资源。

常用API

构造器

在这里插入图片描述

  • permits 表示许可证的数量（资源数）
  • fair 表示公平性，如果这个设为 true 的话，下次执行的线程会是等待最久的线程
常用方法
  • acquire() 表示阻塞并获取许可
  • tryAcquire() 方法在没有许可的情况下会立即返回 false，要获取许可的线程不会阻塞
  • release() 表示释放许可

Semaphore使用

Semaphore实现服务接口限流
package cn.wang.testsync;


import java.lang.management.ManagementFactory;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

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

    private static Executor executor = Executors.newFixedThreadPool(10);
    public static String getProductInfo(){
        try {
            semaphore.acquire();
            System.out.println("请求服务");
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }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 "返回商品详情信息";
    }

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

}

Semaphore实现数据库连接池

public class SemaphoreDemo2 {

    public static void main(String[] args) {
        final ConnectPool pool = new ConnectPool(2);
        ExecutorService executorService = Executors.newCachedThreadPool();

        //5个线程并发来争抢连接资源
        for (int i = 0; i < 5; i++) {
            final int id = i + 1;
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    Connect connect = null;
                    try {
                        System.out.println("线程" + id + "等待获取数据库连接");
                        connect = pool.openConnect();
                        System.out.println("线程" + id + "已拿到数据库连接:" + connect);
                        //进行数据库操作2秒...然后释放连接
                        Thread.sleep(2000);
                        System.out.println("线程" + id + "释放数据库连接:" + connect);

                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        pool.releaseConnect(connect);
                    }

                }
            });
        }
    }
}

//数据库连接池
class ConnectPool {
    private int size;
    private Connect[] connects;

    //记录对应下标的Connect是否已被使用
    private boolean[] connectFlag;
    //信号量对象
    private Semaphore semaphore;

    /**
     * size:初始化连接池大小
     */
    public ConnectPool(int size) {
        this.size = size;
        semaphore = new Semaphore(size, true);
        connects = new Connect[size];
        connectFlag = new boolean[size];
        initConnects();//初始化连接池
    }

    private void initConnects() {
        for (int i = 0; i < this.size; i++) {
            connects[i] = new Connect();
        }
    }

    /**
     * 获取数据库连接
     *
     * @return
     * @throws InterruptedException
     */
    public Connect openConnect() throws InterruptedException {
        //得先获得使用许可证，如果信号量为0，则拿不到许可证，一直阻塞直到能获得
        semaphore.acquire();
        return getConnect();
    }

    private synchronized Connect getConnect() {
        for (int i = 0; i < connectFlag.length; i++) {
            if (!connectFlag[i]) {
                //标记该连接已被使用
                connectFlag[i] = true;
                return connects[i];
            }
        }
        return null;
    }

    /**
     * 释放某个数据库连接
     */
    public synchronized void releaseConnect(Connect connect) {
        for (int i = 0; i < this.size; i++) {
            if (connect == connects[i]) {
                connectFlag[i] = false;
                semaphore.release();
            }
        }
    }
}

/**
 * 数据库连接
 */
class Connect {

    private static int count = 1;
    private int id = count++;

    public Connect() {
        //假设打开一个连接很耗费资源，需要等待1秒
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("连接#" + id + "#已与数据库建立通道！");
    }

    @Override
    public String toString() {
        return "#" + id + "#";

    }

}

应用场景总结

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

CountDownLatch

CountDownLatch（闭锁）是一个同步协助类，允许一个或多个线程等待，直到其他线程完成操作集

小王爷很帅
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JUC并发工具类
qq_44027353的博客
04-03 560
可中断可选择设置公平锁可以设置超时时间支持多个条件变量解决多线程竞争资源的问题，例如多个线程同时对同一个数据库进行写操作，可以使用ReentrantLock保证每次只有一个线程能够写入。实现多线程任务的顺序执行，例如在一个线程执行完某个任务后，再让另一个线程执行任务。实现多线程等待/通知机制，例如在某个线程执行完某个任务后，通知其他线程继续执行任务。ReentrantLock具体的引用场景如下：解决多线程之间资源竞争问题。
06、JUC并发工具类在大厂的应用场景详解-ev
03-07
06、JUC并发工具类在大厂的应用场景详解_ev06、JUC并发工具类在大厂的应用场景详解_ev06、JUC并发工具类在大厂的应用场景详解_ev06、JUC并发工具类在大厂的应用场景详解_ev06、JUC并发工具类在大厂的应用场景详解_ev...
【并发专题】JUC并发工具类在大厂的应用场景详解
qq_32681589的博客
07-18 396
ReentrantLock是一种可重入的独占锁，它允许同一个线程多次获取同一个锁而不会被阻塞。它的功能类似于synchronized是一种互斥锁，可以保证线程安全。Semaphore（信号量）是一种用于多线程编程的同步工具，用于控制同时访问某个资源的线程数量。它通过维护若干个许可证来控制线程对资源的访问。当许可证数量大于零时，线程可以访问；反之，则拒绝，并阻塞线程让其等待。许可证的数量，就是最多可访问线程数。
JUC并发工具类的应用场景详解
Myname_China的博客
02-04 865
jdk提供了比synchronized更加高级的各种同步工具，包括ReentrantLock、Semaphore、CountDownLatch、CyclicBarrier等，可以实现更加丰富的多线程操作。
【Java并发编程】JUC并发工具类及应用场景详解
持续学习，坚持原创，分享技术笔记及经验。
07-19 358
JUC并发工具类在大厂的应用场景详解
并发编程-4.JUC并发工具类的应用场景
weixin_42287045的博客
12-24 867
1.并发编程是为了解决什么问题 2.常用同步并发工具类真实应用场景详解 3.抢票场景如何保证线程安全 4.并发场景下如何实现服务限流和资源控制 5.如何实现多线程批量数据处理 6.并发工具类在对账场景和交易场景的应用
Java并发编程实用工具类JUC的各种场景应用全解
youhaitao_do的博客
09-08 3095
一、JUC 1、SaleTicketDemo.java import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * @author yht * @create 20:46 * * 题目：三个售票员 卖出 30张票 * 笔记：如何编写企业级的多线程代码 * 固定的编程套路+模板是什么？ * 1.在高内聚，低耦合的前提下
【JUC并发工具类与相关的应用场景详解】
weixin_42070243的博客
10-03 106
ReentrantLock是一种可重入的独占锁，允许同一个线程多次获取同一个锁而不被阻塞，同synchronized一样，是一种互斥锁，但是相对synchronized来说，ReentrantLock有以下特点：如下图： 在多个线程同时操作同一个资源时，ReentrantLock相当于是给这些线程加了一道门锁，每个线程想要获取到资源，都需要先获取到这把钥匙，才能访问门锁后面持有的资源ReentrantLock实现了Lock接口规范，常见的API如下： void lockInterruptibly() th
（并发编程学习04）JUC并发工具类的应用场景详解
a250029634的博客
07-17 463
JUC并发工具类的应用场景详解
JUC常见并发工具类
weixin_44339676的博客
02-14 186
JUC常见并发工具类CountDownLatch （倒计时器）CountDownLatch 的两种典型用法CountDownLatch 的不足CyclicBarrier(循环栅栏)CyclicBarrier 的应用场景CyclicBarrier源码分析Semaphore(信号量)-允许多个线程同时访问 CountDownLatch （倒计时器） CountDownLatch 是共享锁的一种实现,它默认构造 AQS 的 state 值为 count。当线程使用 countDown() 方法时,其实使用了try
JUC并发编程之JUC内置常用工具类
xzystart的博客
01-24 201
CountDownLatch 在日常开发中经常会遇到需要在主线程中开启多个线程去并行执行任务，并且主线程需要等待所有子线程执行完毕后再进行汇总的场景。在CountDownLatch出现之前一般都使用线程的join（）方法来实现这一点，但是join方法不够灵活，不能够满足不同场景的需要，所以JDK开发组提供了CountDownLatch这个类能够使一个线程等待其他线程完成各自的工作后再执行。 ​ 工作原理 CountDownLatch是通过一个计数器来实现的，计数器的初始值为初始任务的数量。每当完成了一个任务
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...
9、并发容器（Map、List、Set）实战及其原理.pdf
02-28
6.JUC并发工具类在大厂的应用场景详解 (1).pdf 7、深入理解 AQS 独占锁之 Reentrantlock 源码分析 (1).pdf 8、读写锁ReentrantReadWriteLock&StampLock详解.pdf 9、并发容器 (Map、List、Set） 实战及其原理.pdf 10...
Java 多线程与并发(13-26)-JUC集合- ConcurrentHashMap详解.pdf
07-26
【Java 多线程与并发】并发集合类`ConcurrentHashMap`是Java程序设计中一个重要的工具，尤其在高并发场景下，它提供了高效的线程安全。`ConcurrentHashMap`在JDK 1.7和1.8中有着显著的区别。 在JDK 1.7中，`...
sotowang#bigdata#JUC包1
07-25
JUC中的应用场景并发工具类让一组线程等另一组线程跑完再继续跑每当一子线程完成任务，同步计数器就countDown()一次，直到count为0，此时主线程上的a
【仿真建模-anylogic】FlowchartPort原理解析
zhaoyaxuan001的博客
06-14 352
FlowchartPort是流图组件端口的基类，一般不会直接使用；如果需要自行封装组件库时会用到；FlowchartPort继承Port类，并定义了一系列抽象函数；用于输入端口判定此刻是否不能接收Agent。用于输出端口判定是否有Agent准备离开。判定端口是否发生错误。
（Javascript）AI数字人mp4转canvas播放并去除背景绿幕
lx_nhs的博客
06-12 507
去除前：去除后： 3、可能会出现的报错 （1）视频路径跨域问题：解决：vue开启代理
盲盒App开发时有哪些技术框架可以借鉴
最新发布
bytekj的博客
06-14 577
在开发盲盒App时，可以根据项目需求和团队技术栈选择合适的技术框架。前端可以选择微信小程序框架、React Native或Vue.js等；后端可以选择Node.js或Spring Boot等；数据库可以选择MySQL或MongoDB等。同时，还需要考虑缓存、消息队列、支付和物流接口等其他技术来完善应用的功能和性能。
【Java02】Java中数组的定义与初始化
饮冰室
06-10 626
推荐第一种方式。这种方式容易让人理解，数据类型是type[]，对象名称是arrayName。第二种方式有些老旧了。由于数组是一种引用变量（也就是一个指针），所以定义的时候还没有指向任何有效的内存空间，因此在定义数组的时候不能指定数组的长度，也不能直接使用。必须进行初始化。可以使用var让系统自动推断变量类型，既可以用于静态初始化，也可以用于动态初始化。
Java中常见的juc并发类有哪些？
04-19
Java中常见的juc并发类有：锁类（Lock）、原子类（Atomic）、线程池（ThreadPoolExecutor）、阻塞队列（BlockingQueue）、信号量类（Semaphore）、循环栅栏类（CyclicBarrier）、倒计数器类（CountDownLatch）、并发...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值