JUC入门（1）---＞ 前置知识

最新推荐文章于 2024-08-07 11:15:21 发布
最新推荐文章于 2024-08-07 11:15:21 发布
阅读量236 收藏 1
点赞数 1
分类专栏： JUC 文章标签： java 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/You_are_mine/article/details/109458075
版权

JUC入门（1）—> 前置知识

1、什么是JUC？

java.util.concurrent 在并发编程中使用的工具类
在这里插入图片描述

2、Java中实现多线程的三种方法，区别对比：

在这里插入图片描述

  • 实现Runnable接口相比继承Thread类有如下优势：

  • 实现Runnable接口和实现Callable接口的区别:

3、进程和线程

进程是程序的一次执行过程

是一个动态概念，是程序在执行过程中分配和管理资源的基本单位，每一个进程都有一个自己的地址空间，至少有 5 种基本状态，它们是：初始态，执行态，等待状态，就绪状态，终止状态。

线程是CPU调度和分派的基本单位，

它可与同属一个进程的其他的线程共享进程所拥有的全部资源。

4、并发和并行

  • 并发（Concurrent）：指两个或多个事件在同一时间间隔内发生，即交替做不同事的能力，多线程是并发的一种形式
  • 并行（Parallel）：指两个或者多个事件在同一时刻发生，即同时做不同事的能力

5、线程的状态

public enum State {
       	// 新生
        NEW,

        // 运行
        RUNNABLE,

        // 阻塞
        BLOCKED,

        // 等待
        WAITING,

        // 超时等待
        TIMED_WAITING,

        // 终止
        TERMINATED;
    }
线程之间的通信，参考下面博客：

线程间通信的几种实现方式

6、wait/sleep 区别

图片来源：https://blog.csdn.net/qq_20009015/article/details/89980966

7、Lock 锁（重点）

package com.lixiande.practice1101;

import java.util.concurrent.locks.Lock;

/**
 * @program: juc
 * @description: 基础的买票程序，理解Synchronized
 * @author: Mr.LiXianDe
 * @create: 2020-11-01 16:17
 **/
public class SellingTickets {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        // @FunctionalInterface 函数式接口，jdk1.8 lambda表达式 (参数)->{ 代码 }
        new Thread(() -> {
            for(int i = 1; i < 40;i++){
                ticket.sale();
            }
        },"A").start();
        new Thread(() -> {
            for(int i = 1; i < 40;i++){
                ticket.sale();
            }
        },"B").start();
        new Thread(() -> {
            for(int i = 1; i < 40;i++){
                ticket.sale();
            }
        },"C").start();
    }
}
// 资源类OOP
class Ticket{
    // 属性、方法
    private int numbers = 30;
    // 卖票方式
    // synchronized本质：队列，锁
    public synchronized void sale(){
        if(numbers > 0){
            System.out.println(Thread.currentThread().getName()+": 卖出了第  "+(numbers--)+"  张票,剩余  "+numbers+"  张票");
        }
    }
}

Lock

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

1、什么是锁？

锁是用于控制多个线程访问共享资源的工具 。 通常，锁提供对共享资源的独占访问：一次只能有一个线程可以获取锁，并且对共享资源的所有访问都要求首先获取锁。 但是，一些锁可能允许并发访问共享资源，如ReadWriteLock的读锁

2、lock与synchronized区别

        虽然synchronized方法和语句的范围机制使得使用监视器锁更容易编程，并且有助于避免涉及锁的许多常见编程错误，但是有时您需要以更灵活的方式处理锁。
        例如，用于遍历并发访问的数据结构的一些算法需要使用“手动”或“链锁定”：您获取节点A的锁定，然后获取节点B，然后释放A并获取C，然后释放B并获得D等。 所述的实施方式中Lock接口通过允许获得并在不同的范围释放的锁，并允许获得并以任何顺序释放多个锁使得能够使用这样的技术。

两者的比较

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

3、如何使用？

在这里插入图片描述

4、锁的介绍

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

https://www.cnblogs.com/gxyandwmm/p/9387833.html
锁的理解（可重入）

package com.lixiande.practice1101;

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

/**
 * @program: juc
 * @description: 基础的买票程序，理解Lock
 * @author: Mr.LiXianDe
 * @create: 2020-11-01 16:17
 **/
public class SellingTicketsPlus {
    public static void main(String[] args) {
        // 并发：多个线程操作同一个资源类，把资源类丢入线程
        TicketAnother ticket = new TicketAnother();

        new Thread(() -> {
            for(int i = 1; i < 40;i++){
                ticket.sale();
            }
        },"A").start();

        new Thread(() -> {
            for(int i = 1; i < 40;i++){
                ticket.sale();
            }
        },"B").start();

        new Thread(() -> {
            for(int i = 1; i < 40;i++){
                ticket.sale();
            }
        },"C").start();
    }
}

// Lock三部曲
// 1、 new ReentrantLock();
// 2、 lock.lock(); // 加锁
// 3、 finally=> lock.unlock(); // 解锁
class TicketAnother{
    private int numbers = 30;
    Lock lock = new ReentrantLock();

    public  void sale(){
        lock.lock(); // 进行锁定
        try{
            //业务代码
            
            if(numbers > 0){
                System.out.println(Thread.currentThread().getName()+": 卖出了第  "+(numbers--)+"  张票,剩余  "+numbers+"  张票");
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

生产者和消费者问题 Synchronized 版

package com.lixiande.practice1101.SynPKJUC;

/**
 * @program: juc
 * @description: Synchronized版本的生产者消费者问题
 * @author: Mr.LiXianDe
 * @create: 2020-11-01 17:01
 **/
public class ProducerConsumer {
    public static void main(String[] args) {
        Data data = new Data();

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

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

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

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

class Data{
    private int number;

    public synchronized void increment() throws InterruptedException {
        // if (number != 0){ 此处如果用if进行判断，则会产生虚假唤醒
        while (number != 0){
            // 等待操作
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"=>" + number);
        // 通知其他线程（唤醒）
        this.notifyAll();
    }

    public synchronized void decrement() throws InterruptedException {
        while (number == 0){
            // 等待操作
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"=>" + number);
        // 通知其他线程（唤醒）
        this.notifyAll();
    }
}

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

JUC版的生产者和消费者问题

在这里插入图片描述

在这里插入图片描述

package com.lixiande.practice1101.SynPKJUC;

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

/**
 * @program: juc
 * @description: Synchronized版本的生产者消费者问题
 * @author: Mr.LiXianDe
 * @create: 2020-11-01 17:01
 **/
public class ProducerConsumerPlus {
    public static void main(String[] args) {
        DataAnother data = new DataAnother();

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

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

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

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

class DataAnother{
    private int number = 0;
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    public  void increment() throws InterruptedException {
        lock.lock();
        try {
            while (number != 0){
                // 等待操作
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName()+"=>" + number);
            // 通知其他线程（唤醒）
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public  void decrement() throws InterruptedException {
        lock.lock();
        try {
            while (number == 0){
                // 等待操作
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName()+"=>" + number);
            // 通知其他线程（唤醒）
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

Condition 精准的通知和唤醒线程
这也是Lock的优势
多个线程如何控制顺序执行

在这里插入图片描述

package com.lixiande.practice1101.SynPKJUC;

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

/**
 * @program: juc
 * @description: A 执行完调用B，B执行完调用C，C执行完调用A
 * @author: Mr.LiXianDe
 * @create: 2020-11-01 17:01
 **/
public class ProducerConsumerPlusPlus {
    public static void main(String[] args) {
        DataAnotherAnother data = new DataAnotherAnother();

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

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

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

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

class DataAnotherAnother{
    private int number = 1;
    Lock lock = new ReentrantLock();
    Condition conditionA = lock.newCondition();
    Condition conditionB = lock.newCondition();
    Condition conditionC = lock.newCondition();
    Condition conditionD = lock.newCondition();

    public  void printA() throws InterruptedException {
        lock.lock();
        try {
            while (number != 1){
                // 等待操作
                conditionA.await();
            }
            System.out.println(Thread.currentThread().getName()+"=> AAA");
            // 通知其他线程（唤醒）
            number = 2;
            conditionB.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public  void printB() throws InterruptedException {
        lock.lock();
        try {
            while (number != 2){
                // 等待操作
                conditionB.await();
            }
            System.out.println(Thread.currentThread().getName()+"=> BBB");
            // 通知其他线程（唤醒）
            number = 3;
            conditionC.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public  void printC() throws InterruptedException {
        lock.lock();
        try {
            while (number != 3){
                // 等待操作
                conditionC.await();
            }
            System.out.println(Thread.currentThread().getName()+"=> CCC");
            // 通知其他线程（唤醒）
            number = 4;
            conditionD.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public  void printD() throws InterruptedException {
        lock.lock();
        try {
            while (number != 4){
                // 等待操作
                conditionD.await();
            }
            System.out.println(Thread.currentThread().getName()+"=> DDD");
            // 通知其他线程（唤醒）
            number = 1;
            conditionA.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

在这里插入图片描述

PatrickStar_8
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【JUC编程进阶】前置知识
Java—wang的博客
05-11 124
前置知识： JUC：java.util工具包 java默认线程：有两个默认线程，main，GC java真的可以开启线程吗？ 不可以，调用本地方法，底层的C++，Java无法直接操作硬件 并发：多线程操作同一个资源 CPU一核：快速交替，模拟出多线程 CPU多核：多个线程可以同时执行 获取CPU核数：Runtime.getRuntime().availableProcessors() package day1; /** * @author jitwxs * @date 2021年05月11日 17
JUC并发编程与源码分析笔记01-本课程前置知识及要求说明
王劭阳的博客
11-26 630
课程使用IDEA来讲解，要求熟练使用IDEA相关操作。
java juc作者_Java面试之JUC系列：Collection线程不安全的举例
weixin_39889788的博客
03-04 196
Collection线程不安全的举例前言1、当我们执行下面语句的时候，底层进行了什么操作new ArrayList();底层创建了一个空的数组，伴随着初始值为10当执行add方法后，如果超过了10，那么会进行扩容，扩容的大小为原值的一半，也就是5个，使用下列方法扩容Arrays.copyOf(elementData, netCapacity)单线程环境下单线程环境的ArrayList是不会有问题的...
JUC的三大常用辅助类，你都知道吗？
不会编程的派大星的博客
04-24 187
1.countDownLatch 减法计数器：实现调用几次线程后，在触发另一个任务 简单代码实现： *举例说明：就像五个人在同一房间里，有一个看门的大爷，当五个人都出去后，他才能锁门，也就是说 执行5次出门这个动作的线程后，才出发了锁门的这个动作 import java.util.concurrent.CountDownLatch; /** * @program: juc * @description * @author: 不会编程的派大星 * @create: 2021-04-24 16:55
JUC高级十-并发加锁原理之AbstractQueuedSynchronizer(AQS)
qq_31745863的博客
04-15 568
如果共享资源被占用，就**需要一定的阻塞等待唤醒机制来==保证锁分配==**。这个机制主要用的是CLH队列的变体实现的，**将暂时获取不到锁的线程加入到队列中**，这个队列就是AQS的抽象表现。它将请求共享资源的线程封装成队列的结点（`Node`），通过`CAS`、`自旋`以及`LockSupport.park()`的方式，维护`state变量`的状态，使并发达到同步的效果。
Shiro 入门教程 - Shiro 授权
smart_an的专栏
07-18 650
作者简介：大家好，我是哥，前中兴通讯、美团架构师，现某互联网公司联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬学习必须往深处挖，挖的越深，基础越扎实！
Shiro 入门教程 - Shiro 多项目
smart_an的专栏
07-21 877
作者简介：大家好，我是哥，前中兴通讯、美团架构师，现某互联网公司联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬学习必须往深处挖，挖的越深，基础越扎实！
Shiro 入门教程 - Shiro 身份验证
smart_an的专栏
07-18 773
学习必须往深处挖，挖的越深，基础越扎实！阶段1、深入多线程 阶段2、深入多线程设计模式 阶段3、深入juc源码解析 阶段4、深入jdk其余源码解析 阶段5、深入jvm源码解析码哥源码部分码哥讲源码-原理源码篇【2024年最新大厂关于线程池使用的场景题】码哥讲源码【炸雷啦！炸雷啦！黄光头他终于跑路啦！】码哥讲源码-【jvm课程前置知识及c/c++调试环境搭建】​​​​​​码哥讲源码-原理源码篇【揭秘join方法的唤醒本质上决定于jvm的底层析构函数】码哥源码-原理源码篇【Doug Lea为什么要将成员变量
Shiro 入门教程 - Shiro Realm
smart_an的专栏
07-18 581
即用户 - 角色之间是多对多关系，角色 - 权限之间是多对多关系；且用户和权限之间通过角色建立关系；在系统中验证时通过权限验证，角色只是权限集合，即所谓的显示角色；其实权限应该对应到资源（如菜单、URL、页面按钮、Java 方法等）中，即应该将权限字符串存储到资源实体中，但是目前为了简单化，直接提取一个权限表，【综合示例】部分会使用完整的表结构。用户实体包括：编号 (id)、用户名 (username)、密码 (password)、盐 (salt)、是否锁定 (locked)；
JUC-High-Concurrency:java.util.concurrent JUC高并发处理
04-03
本篇将深入探讨JUC中的重要知识点，包括同步、可重入锁、类对象锁、高并发集合以及可调用接口。 首先，我们来看同步机制。在Java中，同步主要用于控制对共享资源的访问，防止数据的不一致性。同步可以通过...
JUC编程笔记-zfs.pdf
04-11
JUC 编程笔记 - zfs.pdf 本笔记主要讲解了 Java 中的并发编程相关知识，包括进程和线程、并发和并行、异步和同步等概念的解释和区别。 进程与线程 进程是指令和数据的集合，程序被加载到内存中，CPU 执行指令，...
java7hashmap源码-knowledge-juc:知识-juc
06-04
Java 7的实现相对简单，通过`key.hashCode() ^ (key.hashCode() >>> 16)`来减少哈希冲突。 2. **扩容机制**：当HashMap的负载因子（当前元素数量/数组大小）达到0.75时，会触发扩容。扩容过程涉及到创建一个新的两...
A-JUC-JVM-Java并发知识..pdf
06-05
互联网大厂开发高频面试及知识点总结 涉及JUC 包下的并发相关知识梳理 JVM及参数调优案例等
heima-JUC-资料
04-25
Java并发编程是Java Util Concurrency（JUC）库的核心内容，它为多线程环境提供了高效、安全且灵活的工具和API。JUC是Java 5及后续版本引入的一个重要特性，极大地提升了Java在多处理器和高并发环境下的性能表现。 ...
【Spring Boot】高效配置管理: 易用性与灵活性并重
weixin_68020300的博客
08-07 1248
本文探讨了Spring Boot中多样化的配置读取方法及其应用场景，强调了配置管理的重要性，并展示了Spring Boot如何通过灵活多变的配置选项简化这一过程。此外，文章还展望了配置管理领域未来的技术趋势和发展方向。对于任何希望深入了解Spring Boot配置管理的开发者来说，这是一篇不容错过的好文。
C++ - 函数重载
jiaowenjie的专栏
08-06 328
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
伐木工 (100%用例)D卷 (Java&&Python&&C++&&Node.js&&C语言)
荆赫同艺的博客
08-07 218
一根 4米长的树木，伐木工不需要切割为 2*2，省去切割成本，直接整根树木交易，为 4*1，收益最大为 4。方式二: 3,2,2,3，但方式二，伐木工多切割一次，增加了切割成本却卖了一样的价格，因此并不是最优收益。一根 2 米长的树木，伐木工不切割，为2*1，收益最大为 2。一根5 米长的树木，伐木工切割为 2*3,收益最大为 6。输出最优收益时的各个树木长度，以空格分隔，按升序排列。一根 10 米长的树木，伐木工可以切割。方式一:3,4,4，也可以切割为。
Spring事务
最新发布
c1tenj2的博客
08-07 436
以银行转账为例，一次转账操作伴随着一个账户的扣钱和另一个账户的加钱，这个流程是一个原子操作，要么同时发生，一气呵成，要么都不做。AccountServiceImpl实现AccountService接口，里面只有一个转账方法AccountMapper以及其映射文件account数据库测试代码用1/0模拟程序运行时出现异常的情况由于没有开启事务，出现了莫名其妙少了100块钱的情况，说明这个事务不是连续的。
狂神说java-juc并发编程
09-23
狂神说java-juc并发编程是指狂神在讲解Java并发编程时提到了Java Util Concurrent（简称JUC）这个包。JUC是Java中用于处理并发编程的三个包之一，它包含了一系列的并发工具类和线程安全的集合类。其中，java.util.concurrent.atomic包提供了一些原子性操作的类，可以保证线程安全地对变量进行操作；java.util.concurrent.locks包提供了各种锁，如ReentrantLock和ReadWriteLock，用于实现更加复杂的线程同步控制；java.util.concurrent包则提供了一些高级的并发工具类，如CountDownLatch、CyclicBarrier、Semaphore等，用于协调多个线程的执行。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值