JUC并发编程学习（一）

最新推荐文章于 2023-10-16 22:42:11 发布
最新推荐文章于 2023-10-16 22:42:11 发布
阅读量297 收藏 1
点赞数 1
分类专栏： 多线程 java 文章标签： 多线程 并发编程 java thread juc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43827693/article/details/110246098
版权

JUC并发编程学习（一）

一、线程

1、wait和sleep区别

1）、来自不同的类

wait 是 object类的
sleep是 Thread类的

2）、关于锁的释放

wait会释放锁，sleep不会释放锁。

3）、使用的范围不同

wait 必须在同步代码块中使用
sleep 可以在任何地方使用

二、Lock锁

1、synchronized

略

2、Lock

在这里插入图片描述
在这里插入图片描述

1)、ReentrantLock

ReentrantLock–>可重入锁，使用new创建的时候如下:
在这里插入图片描述
默认无参构造为非公平锁，有参构造传true为公平锁。
公平锁：线程获取锁的顺序和调用lock的顺序一样，先来后到；
非公平锁：线程获取锁的顺序和调用lock的顺序无关，全凭运气

3、synchronized 和 Lock的区别

1、synchronized 是内置的关键字，Lock 是一个Java类；
2、synchronized 无法判断获取锁的状态，Lock 可以判断是否获取到了锁；
3、synchronized 会自动释放锁，Lock 必须要手动释放锁，否则会死锁；
4、synchronized 对 线程1 加锁（这时线程1阻塞），线程2就会一直等待，Lock锁就不一定会等待下去；
5、synchronized 可重入、不可中断、非公平锁；Lock 可重入、可判断锁、非公平（可以自己设置）；
6、synchronized 适合锁少量的代码同步问题，Lock 适合锁大量的同步代码。

三、生产者和消费者

1、Synchronized 版

大致流程为：判断等待=》业务逻辑=》通知其他线程
配套的方法为：
在这里插入图片描述

1）、实现案例

资源类：

package com.zhan.juc.lock.producerAndconsumer;

/**
 * @Author Zhanzhan
 * @Date 2020/11/28 13:12
 * 资源类
 */
public class Data {
    private int number = 0;

    /**
     * 增量方法，number + 1
     */
    public synchronized void increment() throws InterruptedException {
        if (number != 0){
            // 等待
            this.wait();
        }
        // 开始具体的业务逻辑
        number++;
        System.out.println(Thread.currentThread().getName() + "=>" + number);
        // 加完后，通知其他线程 +1 操作完毕了
        this.notifyAll();
    }

    /**
     * 减量操作，number - 1
     */
    public synchronized void decrement() throws InterruptedException {
        if (number == 0){
            // 等待
            this.wait();
        }
        // 开始具体的业务逻辑
        number--;
        System.out.println(Thread.currentThread().getName() + "=>" + number);
        // 减完后，通知其他线程 -1 操作完毕了
        this.notifyAll();
    }
}

线程操作类：

package com.zhan.juc.lock.producerAndconsumer;

/**
 * @Author Zhanzhan
 * @Date 2020/11/28 13:11
 * 线程之间的通信问题
 * 线程交替执行
 * A线程 和 B线程 操作 同一个变量 num，当 A 将 num+1 时，通知 B 将 num-1
 */
public class Demo1 {
    public static void main(String[]args){
        Data data = new Data();
        new Thread(()->{
            for (int i = 0;i<10;i++){
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "A").start();
        new Thread(()->{
            for (int i = 0;i<10;i++){
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "B").start();
    }
}

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

2）、存在的问题

目前只是模拟了A和B两个线程，那如果扩展到三个或者四个线程呢，会有什么情况？
我们将上面的线程操作类稍加变换，扩展到四个线程（A、B、C、D），A和C线程执行增量的increment()，B和D执行减量的decrement()，如下：

package com.zhan.juc.lock.producerAndconsumer;

/**
 * @Author Zhanzhan
 * @Date 2020/11/28 13:11
 * 线程之间的通信问题
 * 线程交替执行
 * A线程 和 B线程 操作 同一个变量 num，当 A 将 num+1 时，通知 B 将 num-1
 */
public class Demo1 {
    public static void main(String[]args){
        Data data = new Data();
        new Thread(()->{
            for (int i = 0;i<10;i++){
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "A").start();

        new Thread(()->{
            for (int i = 0;i<10;i++){
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "B").start();

        new Thread(()->{
            for (int i = 0;i<10;i++){
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "C").start();

        new Thread(()->{
            for (int i = 0;i<10;i++){
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "D").start();
    }
}

结果如下：
在这里插入图片描述
我们很神奇的发现，结果和我们的预期严重不符。那么问题在哪儿呢？
在这里插入图片描述
这里的判断需要使用while进行判断，可以防止虚假唤醒，所以我们需要将资源类稍加修改，如下：

package com.zhan.juc.lock.producerAndconsumer;

/**
 * @Author Zhanzhan
 * @Date 2020/11/28 13:12
 * 资源类
 */
public class Data {
    private int number = 0;

    /**
     * 增量方法，number + 1
     */
    public synchronized void increment() throws InterruptedException {
        while (number != 0){
            // 等待
            this.wait();
        }
        // 开始具体的业务逻辑
        number++;
        System.out.println(Thread.currentThread().getName() + "=>" + number);
        // 加完后，通知其他线程 +1 操作完毕了
        this.notifyAll();
    }

    /**
     * 减量操作，number - 1
     */
    public synchronized void decrement() throws InterruptedException {
        while (number == 0){
            // 等待
            this.wait();
        }
        // 开始具体的业务逻辑
        number--;
        System.out.println(Thread.currentThread().getName() + "=>" + number);
        // 减完后，通知其他线程 -1 操作完毕了
        this.notifyAll();
    }
}

再次运行，结果如下：
在这里插入图片描述
我们发现，这次完美的符合预期。

2、Lock版

在这里插入图片描述

1）、代码实现

资源类：

package com.zhan.juc.producerAndConsumer.lock;

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

/**
 * @Author Zhanzhan
 * @Date 2020/11/28 14:27
 */
public class Data2 {
    private int number = 0;

    private final Lock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();

    /**
     * 增量方法，number + 1
     */
    public void increment() {
        lock.lock();// 加锁
        try {
            while (number != 0){
                // 等待
                condition.await();
            }
            // 开始具体的业务逻辑
            number++;
            System.out.println(Thread.currentThread().getName() + "=>" + number);
            // 加完后，通知其他线程 +1 操作完毕了
            condition.signalAll();// 唤醒全部等待线程
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            lock.unlock();// 释放锁
        }
    }

    /**
     * 减量操作，number - 1
     */
    public void decrement() {
        lock.lock();// 加锁
        try {
            while (number == 0){
                // 等待
                condition.await();
            }
            // 开始具体的业务逻辑
            number--;
            System.out.println(Thread.currentThread().getName() + "=>" + number);
            // 减完后，通知其他线程 -1 操作完毕了
            condition.signalAll();// 唤醒全部等待线程
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            lock.unlock();// 释放锁
        }
    }
}

线程操作类：

package com.zhan.juc.producerAndConsumer.lock;

/**
 * @Author Zhanzhan
 * @Date 2020/11/28 14:38
 */
public class Demo2 {
    public static void main(String[]args){
        Data2 data = new Data2();
        new Thread(()->{
            for (int i = 0;i<10;i++){
                data.increment();
            }
        }, "A").start();

        new Thread(()->{
            for (int i = 0;i<10;i++){
                data.decrement();
            }
        }, "B").start();

        new Thread(()->{
            for (int i = 0;i<10;i++){
                data.increment();
            }
        }, "C").start();

        new Thread(()->{
            for (int i = 0;i<10;i++){
                data.decrement();
            }
        }, "D").start();
    }
}

运行结果：
在这里插入图片描述
显示结果和预期一样。

2）、功能进阶

上面的实例中，我们看到结果，发现A B C D四个线程不是按照我们写出的顺序有序执行，而是四个线程间随机执行，那么我们如果想要多个线程间有序执行，或者要精准的通知和唤醒指定线程，能实现吗？
我们这里可以使用Condition类的signal()来实现精准唤醒，上代码：

package com.zhan.juc.producerAndConsumer.lock;

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

/**
 * @Author Zhanzhan
 * @Date 2020/11/28 14:46
 * 实现多个线程间的精确唤醒和通知
 * A 执行完 调用 B， B 执行完 调用 C， C 执行完 调用 A
 */
public class Demo3 {
    public static void main(String[]args){
        Data3 data = new Data3();

        new Thread(()->{
            for (int i = 0;i < 10;i++){
                data.printA();
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0;i < 10;i++){
                data.printB();
            }
        },"B").start();

        new Thread(()->{
            for (int i = 0;i < 10;i++){
                data.printC();
            }
        },"C").start();
    }
}

/**
 * 资源类
 */
class Data3{
    private final Lock lock = new ReentrantLock();
    private final Condition condition1 = lock.newCondition();
    private final Condition condition2 = lock.newCondition();
    private final Condition condition3 = lock.newCondition();
    private int number = 1;// 1 -> A, 2 -> B, 3 -> C

    /**
     * A线程执行
     */
    public void printA(){
        lock.lock();
        try {
            // 业务， 判断 -> 执行 -> 通知
            while (number != 1){
                // 等待
                condition1.await();// 将同步代码块 printA() 关入 小黑屋 condition1
            }
            System.out.println(Thread.currentThread().getName()+ "运行---");
            number = 2;
            // 通知 指定的线程
            condition2.signal();// 小黑屋 condition2 开门，放出里面关的
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    /**
     * B线程执行
     */
    public void printB(){
        lock.lock();
        try {
            // 业务， 判断 -> 执行 -> 通知
            while (number != 2){
                // 等待
                condition2.await();// 将同步代码块 printB() 关入 小黑屋 condition2
            }
            System.out.println(Thread.currentThread().getName()+ "运行---");
            number = 3;
            // 通知 指定的线程
            condition3.signal();// 小黑屋 condition3 开门，放出里面关的
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    /**
     * C线程执行
     */
    public void printC(){
        lock.lock();
        try {
            // 业务， 判断 -> 执行 -> 通知
            while (number != 3){
                // 等待
                condition3.await();// 将同步代码块 printC() 关入 小黑屋 condition3
            }
            System.out.println(Thread.currentThread().getName()+ "运行---");
            number = 1;
            // 通知 指定的线程
            condition1.signal();// 小黑屋 condition1 开门，放出里面关的
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

运行结果如下：
在这里插入图片描述
完美符合我们的预期。

书生灬今天不吃饭
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JUC并发编程学习
xu_jin_shan的博客
07-10 404
JUC并发编程学习 JUC概述 Lock接口 线程间通信 线程间定制化通信 集合的线程安全 多线程锁 Callable接口 JUC强大的辅助类 ReentrantReadWriteLock读写锁 BlockingQueue阻塞队列 ThreadPool线程池 Fork/Join分支合并框架 CompleteableFuture异步调用...
JUC并发编程学习笔记
qq_40306697的博客
05-02 181
1.进程和线程 进程: 一个程序, QQ.exe Music.exe程序的集合; 一个进程往往可以包含多个线程, 至少包含一个! 线程: 一个进程的多个子程序, 敲代码可以一边打字一边自动保存 2.Java真的可以开启线程吗? 不可以, start方法内部调用的是一个native本地方法—start0(), 属于底层的C++开启的线程, Java无法直接操作硬件 3.并发和并行 并发(多线程操作同...
【并发编程】JUC并发编程（彻底搞懂JUC）
DreamSun的博客
03-29 6239
JUC实际上就是我们对于jdk中java.util .concurrent 工具包的简称，其结构如下：这个包下都是Java处理线程相关的类，自jdk1.5后出现。目的就是为了更好的支持高并发任务。让开发者进行多线程编程时减少竞争条件和死锁的问题！JUC主要是指JDK8中java.util.concurrent里提供的一系列线程并发工具，但是线程并发的问题远不止几个工具这么简单。要学习工具使用，更要能深入理解工具的原理以及处理线程并发问题的思路。
JUC并发编程——线程池学习：基础概念及三大方法、七大参数、四大拒绝策略（基于狂神说的学习笔记）
whale_cat的博客
10-16 520
在上述例子中，因为for循环开启了10个线程，大于线程池的最大承载量(5+3=8)，如果线程处理速度不够快，在最大承载量到达之前又来了请求，则会触发拒绝策略，而AbortPolicy()拒绝策略则是，当超过线程池最大承载量时，则会放弃之后请求，并抛出异常。maximumPoolSize：线程池最大容量（线程池并非时时刻刻所有线程都开启的，时时刻刻一直开启的只有核心线程），当阻塞队列已满，线程池还有未开启线程时，线程池将会开启未启动的线程。池化技术的本质：事先准备好一些资源，线程复用，用完即还，方便管理。
JUC并发编程学习笔记（狂神）
qq_40826814的博客
04-19 133
感谢原作者和狂神https://blog.csdn.net/weixin_44491927/article/details/108560692 JUC并发编程 1. 什么是JUC 2. 线程和进程 1）进程 2）线程 3）并发 4）并行 5）线程的状态 6）wait/sleep 3.Lock 1）传统的 synchronized 2）Lock 3. Synchronized 与Lock 的区别 4. 生..
juc并发编程脑图以及相关示例代码
07-30
juc并发编程脑图以及相关示例代码
JUC并发编程.rar
12-14
总之，"JUC并发编程.rar"是一个宝贵的资源，它涵盖了Java并发编程的关键方面，无论你是想提升你的并发编程技能，还是在面临并发问题时寻找解决方案，这个资料都将大有裨益。通过深入学习和实践，你将能够更好地理解...
Java后端开发，JUC并发编程Java后端开发，JUC并发编程
04-14
Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程...
JUC并发编程学习笔记(硅谷)
07-23
"JUC并发编程学习笔记(硅谷)"很可能包含了关于Java并发工具集（Java Util Concurrency, JUC）的深入理解和实战经验。JUC是Java标准库提供的一套强大的并发处理工具，它极大地简化了多线程编程，提高了程序的可读性...
尚硅谷大厂必备技术之JUC并发编程基础视频 配套资料（自己根据视频整理课件，和代码）
09-23
【尚硅谷】大厂必备技术之JUC并发编程视频 配套资料，自己根据视频整理 pdf 课件，和代码 视频地址：...
深入理解JUC并发编程：从入门到高级应用全面解析
canshanyin的博客
05-11 583
作为程序员，我们经常需要处理并发编程的问题，但是并发编程的本质却是十分复杂的。Java并发编程可以说是一个十分庞大且重要的领域，而JUC（Java Util Concurrent）则是Java并发编程的基石。那么，什么是JUC并发编程呢？JUC是在Java 5中引入的一个并发编程的扩展库，目的是为了更加方便、快捷和安全地实现并发编程。它提供了一系列的工具类、锁、队列以及原子类等来协调多线程之间的操作。这些工具可以帮助我们有效地管理共享资源和控制线程的执行。
狂神说JUC并发编程学习笔记
qq_40492693的博客
04-17 768
JUC 就是 java.util .concurrent 工具包的简称。这是一个处理线程的工具包，JDK1.5 开始出现的
Juc并发编程学习笔记---狂神说（全）
ProGram_Java521的博客
10-31 1439
Juc并发编程学习笔记---狂神说（全）
《尚硅谷高级技术之JUC高并发编程》学习笔记01——JUC概述
weixin_43301424的博客
11-18 551
文章目录什么是JUC进程和线程的概念进程与线程进程状态wait() / sleep() 的区别并发与并行管程用户线程和守护线程总结 什么是JUC JUC 是 java.util .concurrent 工具包的简称，是处理线程的工具包，从 Java1.5 开始出现。 进程和线程的概念 进程与线程 进程 ( process ) 是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。 线程 ( thread ) 是操作系统能够进行运算调度的最小单位。它被包含在
编程路学习书单推荐
void的博客
09-07 538
Java基础 《Java核心技术卷一》 《Java编程思想》/ 《On Java 8》 《Java并发编程艺术》 《Java并发编程之美》 《深入理解Java虚拟机》 数据库 《数据库概论》 《MySQL必知必会》 《MySQL是怎样运行的》 – 掘金小册（强烈推荐） 《高性能MySQL》，可只看重点章节 《Redis设计与实现》 《Redis深度历险：核心原理和应用实践》 – 掘金小册 数据结构与算法 《算法图解》 《数据结构与算法分析 java语言描述》 《算法 第4版》 （配合leetcode刷题)
JUC并发编程，看这一篇就够了
一个沉迷Java，无法自拔的Coder
07-25 6277
数万字长文，搭配代码，带你学习JUC并发编程；看了狂神的课程以及自己做的笔记
关于并发编程的书籍推荐
青藤光年的博客
04-23 5697
并发编程是Java进阶的必备技能，我们总是觉得并发编程很难，其实并没有那么可怕，只要浸心学习就会有所收获，这里推荐四本书，并介绍一下每本书的特点，供大家从自己的实际情况选择，这四本书基本上是市面上比较流行、权威的了。 《Java多线程编程核心技术》 这本书比较基础，写的比较细，代码示例比较多，包含了线程的基础使用、线程锁的使用（Synchronized和ReentrantLock）、单例模式、...
Java高并发书籍推荐
曾子墨
05-04 5891
1.Java并发编程实战 （java并发的圣经） 2.多处理器编程的艺术(并发编程的各种算法，java实现，有点难度） 3.并发的艺术 （多核处理器的共享内存模型中的各种算法） 4.Java虚拟机并发编程 （jvm平台上各种语言的并发比较，如java，scala，clojure） 5.Java并发编程的艺术 6.Java 7并发编程实战手册 （java中的并发编程实践，属于API工具书，...
JUC学习指南
每个人都是独一无二的，把握好自己的节奏，跟着自己的心走。
04-07 887
文章目录前言学习指南 前言 主要推荐一些视频、博客、专栏来学习juc。本人也是初学小白一枚，之后会深入学习juc知识点的。 博主文章汇总：博客目录索引(持续更新) 学习指南 学习时间：2021.3.26-2021.4.7 这段时间学习了下JUC，说下学习过程吧。入门JUC，建议先要有一些多线程的基础。 ①可以先去掌握一些基础知识点可以看《实战Java高并发程序设计》第一章节。 ②有了基础之后，建议可以先看狂神的视频入门(也就是下面第一个视频)，看的过程中你需要去实操去看一些源码，结合查阅博客大致去了解更
juc并发编程线程池
最新发布
06-18
线程池是并发编程中常用的一种机制，它允许您预先创建一组线程，并在需要执行任务时重用这些线程，从而提高性能和资源管理。 `Executors`类提供了一些预定义的线程池工厂方法，如`newFixedThreadPool()`, `...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值