JUC并发工具类的使用

已于 2023-04-09 22:02:43 修改
阅读量307 收藏
点赞数
分类专栏： java基础语法 文章标签： java
于 2023-04-09 22:01:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zly03/article/details/130048839
版权

今天主要来和大家分享一下JUC相关的一些简单知识，线程池文章就不介绍了，前面的文章有介绍，本文主要介绍Lock和认识synchronized和并发的一些工具类的使用。

Lock

传统的锁有synchronized关键字，我们可以直接在方法和代码块中使用它。

在Java中有ReentrantLock、ReentrantReadWriteLock

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pDKdkJEn-1681048604288)(D:\卓面\学习文件\学习内容\博客\images\2023-04-09-20-51-02-image.png)]

常用的ReentrantLock，默认采用的是非公平锁，也有公平锁的实现方式，简单点说，

  • 公平锁需要根据申请锁的顺序来获取锁，按照先来先服务的原则。

  • 非公平锁可以不按照申请锁的顺序，后申请的线程也可以按先申请锁的线程先获取锁。

public ReentrantLock() {
    sync = new NonfairSync();
}
/**
 * Creates an instance of {@code ReentrantLock} with the
 * given fairness policy.
 *
 * @param fair {@code true} if this lock should use a fair ordering policy
 */
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

下面我们也可以通过一个卖票的小例子来看ReentrantLock的使用，其中最主要的是lock和unlock方法，这方法需要成对出现，否则可能会出现锁未释放的情况。

class Ticket1 {

    private int number = 50;

    Lock lock = new ReentrantLock();
    /**
     * 卖票的方式
     */
    public synchronized void sale() {
        // 加锁
        lock.lock();
        try {
            if (number > 0) {
                System.out.println(Thread.currentThread().getName() + "卖出了" + (number--) + "票，剩余" + number);
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

简单对比Lock和synchronized：

  • synchronized和Lock的类型不同，一个是关键字，一个是类。

  • Lock可以判断锁的状态，而synchronized是不可以的。

  • synchronized的锁释放是自动释放的，而Lock是需要手动释放锁。

  • synchronized线程会一直等待，而Lock是不一定等待下去。

  • synchronized是可重入锁，是非公平锁，Lock可以重入锁，可以设置是否公平。

  • Lock适合锁大量代码，synchronized适合锁少量的代码。

生产者的消费者问题

synchronized版

这个问题一直都是比较经典的问题，我们可以使用synchronized关键字实现配置wait方法，notifyAll方法和notify方法实现。

注意wait方法只能出现在同步方法中。

下面的例子需要防止虚假唤醒的问题，即需要采用循环的方式而不能采用if的方式，在JDK1.8文章的也有说明

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NhGrVHKm-1681048604291)(D:\卓面\学习文件\学习内容\博客\images\2023-04-04-15-55-21-image.png)]

class Data {

    private int number = 0;
    /**
     * 资源类
     */
    public synchronized void increment() {
//      if (number != 0) {
        while (number != 0) {
            // 等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        number++;
        System.out.println(Thread.currentThread().getName() + "=>" + number);

        // 通知其他线程
        this.notifyAll();
    }

    public synchronized void decrement() {
//      if (number == 0) {
        while (number == 0) {
            // 等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        number--;
        System.out.println(Thread.currentThread().getName() + "=>" + number);
        // 通知
        this.notifyAll();
    }
}
Lock版

可能有人也会说，有synchronize不九可以处理了么，在Java中还有一个配合也是可以实现这个功能的，也就是Lock配置Condition的await方法和signal方法，这个比synchronizd强在哪里呢？这个可以实现精准唤醒，而通过synchronized方法里面的notify不能实现精准唤醒。

下面这个例子就可以实现按顺序实现唤醒。

class Data2 {
    private Lock lock = new ReentrantLock();
    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();
    Condition condition3 = lock.newCondition();
    private int number = 1;

    public void printA() {
        lock.lock();
        try {
            while (number != 1) {
                // 等待
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName() + "=>" + number);
            // 唤醒指定的人
            number = 2;
            condition2.signal();
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void printB() {
        lock.lock();
        try {
            while (number != 2) {
                // 等待
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName() + "=>" + number);
            // 唤醒指定的人
            number = 3;
            condition3.signal();
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void printC() {
        lock.lock();
        try {
            while (number != 3) {
                // 等待
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName() + "=>" + number);
            // 唤醒指定的人
            number = 1;
            condition1.signal();
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

}

理解锁

我们如何判断锁的是谁？锁的是调用该方法的对象还是Class模板呢？这样可以帮助我们深入理解锁。

这里还是采用狂神视频的提到的8锁问题，应该看完就可以理解synchronized锁的判断。

场景一

  1. 是输出发短信还是打电话？发短信

  2. 发短信延迟4秒，是发短信还是打电话？发短信

    synchronized锁的是方法的调用者，两个方法用的是同一把锁，谁先拿到先执行。

public class Test1 {

    @SneakyThrows
    public static void main(String[] args){
        Phone phone = new Phone();
        new Thread(() -> {
            phone.sendMsg();
        }, "A").start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(() -> {
            phone.call();
        }, "B").start();
    }
}


class Phone {

    public synchronized void sendMsg() {
        System.out.println("sendMsg");
    }

    public synchronized void call() {
        System.out.println("call");
    }
}
场景二

  1. 下面先输出哪个结果？发短信还是hello? hello

    hello方法是没有锁的，不是同步方法，不受锁影响

public class Test2 {
    public static void main(String[] args){
        Phone1 phone = new Phone1();
        new Thread(() -> {
            phone.sendMsg();
        }, "A").start();

        new Thread(() -> {
            phone.call();
        }, "B").start();
        new Thread(() -> {
            phone.hello();
        }, "C").start();
    }
}


class Phone1 {

    public synchronized void sendMsg() {
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendMsg");
    }

    public synchronized void call() {
        System.out.println("call");
    }

    public void hello() {
        System.out.println("hello");
    }
}
场景三
  1. 下面重新声明两个对象，一个调用同步发短信方法，一个调用call方法，先执行哪个方法？ call

因为两个同步方法，锁的是方法调用者的对象，这里有两把锁

public class Test2 {
    public static void main(String[] args){
        Phone1 phone1 = new Phone1();
        Phone1 phone2 = new Phone1();
        new Thread(() -> {
            phone1.sendMsg();
        }, "A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            phone2.call();
        }, "B").start();

    }
}

class Phone1 {

    public synchronized void sendMsg() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendMsg");
    }

    public synchronized void call() {
        System.out.println("call");
    }

    public void hello() {
        System.out.println("hello");
    }
}
场景四
  1. 增加两个静态同步方法，只有一个对象，先打印，发短信？打电话？发短信

类一加载就有了，这里锁的Class对象，Class是唯一的

public class Test3 {

    public static void main(String[] args){
        Phone3 phone3 = new Phone3();
        new Thread(() -> {
            phone3.sendMsg();
        }, "A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            phone3.call();
        }, "B").start();
    }
}

class Phone3 {

    public static synchronized void sendMsg() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendMsg");
    }

    public static synchronized void call() {
        System.out.println("call");
    }

    public void hello() {
        System.out.println("hello");
    }
}

  1. 两个对象，是发短信还是打电话？发短信

    Class模板只有一个

public class Test3 {

    public static void main(String[] args){
        Phone3 phone3 = new Phone3();
        Phone3 phone2 = new Phone3();
        new Thread(() -> {
            phone3.sendMsg();
        }, "A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            phone2.call();
        }, "B").start();
    }
}
  1. 一个对象，一个静态同步方法，一个普通同步方法，先发短信，还是先打电话？先打电话

sendMsg锁的是Class模板，call锁的是调用的对象

  1. 如果是两个对象，结果也是一样，结果还是打电话
public class Test4 {

    public static void main(String[] args){
        Phone4 phone4 = new Phone4();
        new Thread(() -> {
            phone4.sendMsg();
        }, "A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            phone4.call();
        }, "B").start();
    }
}

class Phone4 {

    public static synchronized void sendMsg() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendMsg");
    }

    public synchronized void call() {
        System.out.println("call");
    }

}

常见的并发辅助类

CountDownLatch

CountDownLatch里面定义了一个减法计算器，和一个阻塞队列，常用的方法有countDown和await方法，countDown相当于-1，await方法会等待计算器归零，然后再被唤醒向下执行。

public class CountDownLatchDemo {

    public static void main(String[] args) throws InterruptedException {
        // 总数6
        CountDownLatch countDownLatch = new CountDownLatch(5);
        // -1
        countDownLatch.countDown();
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "go out!");
                countDownLatch.countDown();
            }, String.valueOf(i)).start();
        }
        // 等待计数器归零，然后再向下执行
        countDownLatch.await();
        System.out.println("close door!");
    }
}

CyclicBarrier

需要等待线程全部达到共同屏障点的同步辅助，其实就是一个加法计算器，主要是可以实现让一组线程达到同一屏障点，然后再进行后续操作。

public class CyclicBarrierDemo {

    public static void main(String[] args){
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () ->{
            System.out.println("召唤神龙成功！");
        });
        for (int i = 1; i <= 7; i++) {
            int temp = i;
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "收集" + temp + "个龙珠");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

Semaphore

一个计数信号量，其中常用的两个方法acquire用于获取许可证，release释放许可证。

可以用于限流等场景，比如下面的停车场例子，当初始化为一个时，也可以用于做互斥锁。

public class SemaphoreTest {

    public static void main(String[] args){
        // 停车位
        Semaphore semaphore = new Semaphore(3);
        for (int i = 1; i <= 6; i++) {
            new Thread(() -> {
                // 等到
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + "抢到车位");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName() + "离开车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();
                }
            }, String.valueOf(i)).start();
        }
    }
}

读写锁

读锁可以允许多个线程同时读，而写锁只允许一个线程写。

下面的例子模拟了一个缓存，这里也采用volatie关键字，用于保证map的数据的可见性。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lIthBk1J-1681048604299)(D:\卓面\学习文件\学习内容\博客\images\2023-04-04-20-43-56-image.png)]

public class ReadWriteLockDemo {

    public static void main(String[] args){
        MyCache myCache = new MyCache();
        // 多线程写
        for (int i = 1; i <= 5; i++) {
            final int temp = i;
            new Thread(() -> {
                myCache.put(temp + "", temp + "");
            }, String.valueOf(i)).start();
        }
        // 多线程读
        for (int i = 1; i <= 5; i++) {
            final int temp = i;
            new Thread(() -> {
                myCache.get(temp + "");
            }, String.valueOf(i)).start();
        }
    }
}

class MyCache {

    private volatile Map<String, Object> map = new HashMap<>();
    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    /**
     * 一个线程写
     */
    public void put(String key, Object value) {
        readWriteLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "写入");
            map.put(key, value);
            System.out.println(Thread.currentThread().getName() + "写入成功！");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.writeLock().unlock();
        }
    }

    /**
     * 多个线程读
     */
    public void get(String key) {
        readWriteLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "读取");
            Object value = map.get(key);
            System.out.println(Thread.currentThread().getName() + "读取成功:" + value);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock();
        }
    }
}

总结

本文章分享的主要是一些并发工具类的使用和介绍，希望大家喜欢！

参考资料

狂神的JUC视频（B站上有，讲的还可以！ ）

宏远十一冠王
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JUC工具类的使用
BingzangAiyuzi的博客
06-11 312
JUC工具类的使用 简介 JUC指的是java.util.concurrent包下的工具类的简称，在jdk1.5时开始出现。 常用工具类 CountdownLatch CyclicBarrier Semaphore Exchanger 3.工具类的使用 CountdownLatch CountdownLatch的构造方法初始化时会给定一个固定的计数值大小，之后每次调用对象的countdown方法后该值都会减一，当这个值不是0的话，调用对象的await方法会一直阻塞下面的方法，直到为0。 使
juc下常用的五个高并发工具
鱼获飞的博客
03-09 2639
1、CountDownLatch:同步计数器 当CountDownLatch的count计数&gt;0时，await()会造成线程阻塞，当使用countDown()让count-- == 0时，线程结束阻塞。 如果想让其他线程执行完指定程序，其他所有程序都执行结束后再执行，这时可以用CountDownLatch，但计数无法被重置，如果需要重置计数，请考虑使用 CyclicBarrier。下面dem...
JUC常用并发工具类
zhaolk的博客
04-04 451
四个案例带你彻底搞懂java最常见的并发工具类，semaphore，countdownlatch，exchanger，cyclicbarrier。
JUC 并发工具类总结
BurukeYou
07-05 1604
简介 JUC封装了许多并发工具类方便的去对并发线程间的同步访问控制,减少代码的重复开发. CountDownLatch 通过给CountDownLatch设置一个初始值, 然后阻塞程序运行,当计数器初始值变为0后程序才可以继续执行 伪代码案例 将计算年收入这个大任务分成3个小任务并发执行. 3个小任务分别是计算1-4月收入, 计算5-9月收入,计算10-12月收入 等到3个小任务都执行完后, 才去根据3个计算任务的结果汇总年收入 CountDownLatch latch = new CountDow
JUC并发工具类
qq_44027353的博客
04-03 559
可中断可选择设置公平锁可以设置超时时间支持多个条件变量解决多线程竞争资源的问题，例如多个线程同时对同一个数据库进行写操作，可以使用ReentrantLock保证每次只有一个线程能够写入。实现多线程任务的顺序执行，例如在一个线程执行完某个任务后，再让另一个线程执行任务。实现多线程等待/通知机制，例如在某个线程执行完某个任务后，通知其他线程继续执行任务。ReentrantLock具体的引用场景如下：解决多线程之间资源竞争问题。
JUC常见并发工具类
weixin_44339676的博客
02-14 186
JUC常见并发工具类CountDownLatch （倒计时器）CountDownLatch 的两种典型用法CountDownLatch 的不足CyclicBarrier(循环栅栏)CyclicBarrier 的应用场景CyclicBarrier源码分析Semaphore(信号量)-允许多个线程同时访问 CountDownLatch （倒计时器） CountDownLatch 是共享锁的一种实现,它默认构造 AQS 的 state 值为 count。当线程使用 countDown() 方法时,其实使用了try
JUC基础（五）—— 并发工具类
战斧的博客
06-09 2737
之前我们已经讲解了不少JUC的内容，今天我们要讲解另一个方面们就是JUC提供的并发工具类
juc之并发工具类
qq_33789406的博客
07-14 117
并发工具类 AQS 原理 概述 ReentrantLock 原理 非公平锁 读写锁 ReentrantReadWriteLock 注意事项 缓存更新策略 stampedlock Semaphore CountdownLatch Cyclicbarrier
JUC并发编程
热门推荐
识时务者的个人博客
07-08 14万+
JUC并发编程 JUC简介 进程、线程的关系 Java默认有两个线程 线程的六种状态 并发、并行的关系： Lock锁 Synchronized 和 Lock的区别 8锁现象 问题一 : 在标准情况下，两个线程先打印 发短信 还是 打电话 ？ 问题二 : 在发短信方法中，延迟4秒，两个线程先打印 发短信 还是 打电话？ 问题三 : Phone类增加一个普通方法，线程B调用，那么两个线程先打印 发短信
简述JUC四大并发工具类
LeBronJJJ的博客
08-01 479
juc 四大并发工具类(内部都是lock实现的) juc.CountDownLatch 闭锁 一个线程等待一组线程执行完毕后再恢复执行 await() 等待其他线程都执行完毕 通过计数器来判断等待的线程是否全部执行完毕 计数器：countDown方法，被等待线程执行完毕后将计数器值-1 当countDownLatch的值 减为0时无法恢复，这就是叫做闭锁的原因 juc.CyclicBarrier ...
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并发工具包实例.zip
01-28
Java并发工具包实例，包含AQS，LOCK，countdownlatch ，atomic原子类等实例
Java并发编程应该掌握的并发工具类，快来看看你掌握了哪些？
12-20
在我们JDK的并发包中，提供了几个非常有用的并发工具类，比如：CountDownLatch 闭锁、CyclicBarrier 同步屏障、Semaphore 信号量，在线程之间交换数据的一种方式 Exchanger，赶紧操练起来。 2、CountDownLatch 闭锁 ...
JUC多线程学习个人笔记
07-08
JUC（Java Util Concurrent）是Java中用于并发编程的工具包，提供了一组接口和类，用于...并发工具类：JUC提供了一些并发编程的工具类，如Semaphore、CountDownLatch、CyclicBarrier等，可以实现线程间的协作和同步。
自制植物大战僵尸：HTML5与JavaScript实现的简单游戏
m0_73367097的博客
06-08 1909
自制植物大战僵尸
简单的项目部署脚本（转载）
u010230019的博客
06-09 604
有些项目团队喜欢使用docker启动java服务,那么我们同样可以将上述脚本稍做改造,来实现基于shell+docker的简单项目部署能力。可以将核心节点的错误或者失败内容通过webhook发送到对应的告警平台,比如钉钉、飞书机器人等。把~/.ssh/id_rsa.pub内容添加到远程仓库的ssh秘钥中。执行start.sh脚本打包部署。start.sh脚本内容。
Java——简单图书管理系统
最新发布
m0_74100417的博客
06-09 1234
数据类型变量iffor数组方法类和对象封装继承多态抽象类和接口今天就是把上述知识点全部都用起来 图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理
修改菜品——后端Java
weixin_53717695的博客
06-09 412
修改菜品——后端Java
狂神说java-juc并发编程
09-23
JUC是Java中用于处理并发编程的三个包之一，它包含了一系列的并发工具类和线程安全的集合类。其中，java.util.concurrent.atomic包提供了一些原子性操作的类，可以保证线程安全地对变量进行操作；java.util....

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值