JUC并发编程 狂神第三讲

已于 2022-07-30 21:04:54 修改
阅读量55 收藏
点赞数
文章标签： jvm java 面试
于 2022-07-29 23:14:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51809035/article/details/126037291
版权

目录

1、JVM

请谈谈你对Volatile的理解

Volatile 是 java虚拟机提供轻量级的同步机制

  1. 保证可见性
  2. 不保证原子性
  3. 禁止指令重排

什么是JVM

JVM：java内存模型，不存在的东西，概念！约定！

关于JVM的一些同步约定：

  1. 线程解锁前，必须读取主存中的最新值到工作内存中
  2. 线程解锁前，必须把共享变量立刻刷回主存
  3. 加锁和解锁是同一把锁

线程 主内存 工作内存

关于主内存与工作内存之间的具体交互协议，即一个变量如何从主内存拷贝到工作内存、如何从工作内存同步到主内存之间的实现细节，Java内存模型定义了以下8种操作来完成：

  1. lock（锁定）：作用于主内存的变量，把一个变量标识为一条线程独占状态。
  2. unlock（解锁）：作用于主内存变量，把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定。
  3. read（读取）：作用于主内存变量，把一个变量值从主内存传输到线程的工作内存中，以便随后的load动作使用
  4. load（载入）：作用于工作内存的变量，它把read操作从主内存中得到的变量值放入工作内存的变量副本中。
  5. use（使用）：作用于工作内存的变量，把工作内存中的一个变量值传递给执行引擎，每当虚拟机遇到一个需要使用变量的值的字节码指令时将会执行这个操作。
  6. assign（赋值）：作用于工作内存的变量，它把一个从执行引擎接收到的值赋值给工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作。
  7. store（存储）：作用于工作内存的变量，把工作内存中的一个变量的值传送到主内存中，以便随后的write的操作。
  8. write（写入）：作用于主内存的变量，它把store操作从工作内存中一个变量的值传送到主内存的变量中。

Java内存模型还规定了在执行上述八种基本操作时，必须满足如下规则：

  • 如果要把一个变量从主内存中复制到工作内存，就需要按顺寻地执行read和load操作， 如果把变量从工作内存中同步回主内存中，就要按- 顺序地执行store和write操作。但Java内存模型只要求上述操作必须按顺序执行，而没有保证必须是连续执行。
  • 不允许read和load、store和write操作之一单独出现
  • 不允许一个线程丢弃它的最近assign的操作，即变量在工作内存中改变了之后必须同步到主内存中。
  • 不允许一个线程无原因地（没有发生过任何assign操作）把数据从工作内存同步回主内存中。
  • 一个新的变量只能在主内存中诞生，不允许在工作内存中直接使用一个未被初始化（load或assign）的变量。即就是对一个变量实施use和store操作之前，必须先执行过了assign和load操作。
  • 一个变量在同一时刻只允许一条线程对其进行lock操作，但lock操作可以被同一条线程重复执行多次，多次执行lock后，只有执行相同次数的unlock操作，变量才会被解锁。lock和unlock必须成对出现
  • 如果对一个变量执行lock操作，将会清空工作内存中此变量的值，在执行引擎使用这个变量前需要重新执行load或assign操作初始化变量的值
  • 如果一个变量事先没有被lock操作锁定，则不允许对它执行unlock操作；也不允许去unlock一个被其他线程锁定的变量。
  • 对一个变量执行unlock操作之前，必须先把此变量同步到主内存中（执行store和write操作）。

在这里插入图片描述

2、Volatile

保证可见性

public class JMMDemo {
    private static volatile int num = 0;
    public static void main(String[] args) {
        new Thread(()->{
            while(num==0){

            }
        }).start();


        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //需要让上面的线程知道num的值已经为1
        num=1;
        System.out.println(num);
    }
}

2、不保证原子性

原子性：不可分割
线程A在执行任务的时候，不能被打扰不能被分割，同时成功或同时失败。

//不保证原子性
//不保证原子性
public class VDemo02 {

    //volatile 不保证原子性
    //原子类AtomicInteger
    private static AtomicInteger num=new AtomicInteger(0);

    public static void add(){
//        num++;  //不是原子性操作
        num.getAndIncrement();
    }

    public static void main(String[] args) {
        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();
        }

        while(Thread.activeCount()>2){
            Thread.yield();
        }

        //理论上结果为两万
        System.out.println(num);
    }
}

加Volatile结果一直小于两万

不加lock 和 synchronize 怎么保证原子性，使用原子类
java.util.concurrent.atomic
Class AtomicInteger

3、指令重排

什么是指令重排：你写的程序，计算机并不是按照你写的那样执行的
源代码–>编译器优化的重排，–>指令并行也可能重排—>内存系统也会重排，–>执行

处理器会考虑数据之间的依赖性
a b x y 默认值都是0

线程A线程B
x=ay=b
b=1a=2

正常结果：x=0,y=0

线程A线程B
b=1a=2
x=ay=b

指令重排导致的结果：x=2 y=1

volatiile：可以避免指令重排
内存屏障：CPU指令，作用：

  1. 保证特定的操作的执行顺序
  2. 可以保证某些变量的内存可见性（利用这些特性volatile 实现了可见性）
    在这里插入图片描述
    Volatile 是可以保持 可见性，不能保证原子性，由于内存屏障，可以保证避免指令重排的现象产生

3、彻底玩转单例模式

饿汉式，DCL懒汉式

//懒汉式单例
public class LazyMan {
    private LazyMan(){
        System.out.println(Thread.currentThread().getName()+" ok");
        synchronized (LazyMan.class){
            if(lazyMan!=null){
                throw new RuntimeException("不要使用反射");
            }
        }
    }

    private volatile static LazyMan lazyMan;

    //双重检查锁模式 懒汉式单例  DCL懒汉式
    public static LazyMan getInstance(){
        if(lazyMan==null){
            synchronized (LazyMan.class){
                if(lazyMan==null){
                    //不是原子性操作,所以LazyMan前面要加volatile
                    lazyMan=new LazyMan();
                }
            }
        }

        return lazyMan;
        //单线程下没有问题
    }

    public static void main(String[] args) throws Exception {
//        for (int i = 0; i < 10; i++) {
//            new Thread(()->{
//                LazyMan.getInstance();
//            }).start();
//        }
        //反射
//        LazyMan instance = LazyMan.getInstance();
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor();
        LazyMan lazyMan = declaredConstructor.newInstance();
        LazyMan lazyMan2 = declaredConstructor.newInstance();

//        System.out.println(instance);
        System.out.println(lazyMan);
        System.out.println(lazyMan2);

    }
}

//enum  本身也是一个class类
public enum EnumSingle {
    INSTANCE;

    public EnumSingle getInstance(){
        return INSTANCE;
    }
}
class Test{
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        EnumSingle instance = EnumSingle.INSTANCE;
//        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(null);
        /**
         * Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects
         * 	at java.lang.reflect.Constructor.newInstance(Constructor.java:417)
         * 	at com.single.Test.main(EnumSingle.java:20)
         */
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
        declaredConstructor.setAccessible(true);
        EnumSingle enumSingle = declaredConstructor.newInstance();

        System.out.println(enumSingle);
    }
}

4、深入理解CAS

什么是CAS

在这里插入图片描述
CAS：
在这里插入图片描述
自旋锁：

    public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
            var5 = this.getIntVolatile(var1, var2);
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

        return var5;
    }

CAS：比较当前工作内存中的中和主内存中的值，如果这个值是期望的，那么则执行操作！如果不是就一直循环
缺点：

  1. 循环会耗时
  2. 一次性只能保证一个共享变量的原子性
  3. ABA问题

CAS：ABA问题（狸猫换太子）

public class CASDemo {
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(2020);

        //CAS   比较并交换
        //如果是我的期望值，就更新，否则不更新
        System.out.println(atomicInteger.compareAndSet(2020,2022));
        System.out.println(atomicInteger.get());
        System.out.println(atomicInteger.compareAndSet(2022,2020));
        System.out.println(atomicInteger.get());

        System.out.println(atomicInteger.compareAndSet(2020,2021));
        System.out.println(atomicInteger.get());
    }
}

true
2022
true
2020
true
2021

乐观锁可以检查出中间是否有过改动

如何解决
原子引用

5、原子引用

解决ABA问题

public class CASDemo {
    public static void main(String[] args) {
        //原子引用
        //注意，如果泛型是一个包装类，注意对象的引用
        // Integer  -128 ~ 127  之间的是缓存中的，会复用Integer对象，如果超过就不会复用
        //由于底层用的是 == 比较 ，所以要复用对象才行，所以要在该范围之内
        AtomicStampedReference atomicStampedReference = new AtomicStampedReference<Integer>(20,1);

        new Thread(()->{
            //版本号
            int stamp = atomicStampedReference.getStamp();
            System.out.println("a => "+stamp);

            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(atomicStampedReference.compareAndSet(20, 22, stamp, stamp + 1));
            stamp = atomicStampedReference.getStamp();
            System.out.println("a => "+stamp);

            System.out.println(atomicStampedReference.compareAndSet(22, 20,stamp, stamp + 1));
            stamp = atomicStampedReference.getStamp();
            System.out.println("a => "+stamp);

            System.out.println("=== 狸猫换太子 ===");
        },"a").start();

        new Thread(()->{
            int stamp = atomicStampedReference.getStamp();
            System.out.println("b => "+stamp);

            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(atomicStampedReference.compareAndSet(20, 66, stamp, stamp + 1));
            System.out.println("b => "+atomicStampedReference.getStamp());
        },"b").start();
    }
}

6、各种锁的理解

1、公平锁。非公平锁

非公平锁：(默认)

    public ReentrantLock() {
        sync = new NonfairSync();
    }

    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

2、可重入锁

递归锁

synchronize 版：

public class Demo01 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(()->{
            phone.sms();
        },"A").start();
        new Thread(()->{
            phone.sms();
        },"B").start();

    }
}
class Phone{
    public synchronized void sms(){
        System.out.println(Thread.currentThread().getName()+" sms");
        call();
    }

    public synchronized void call() {
        System.out.println(Thread.currentThread().getName()+" call");
    }
}

lock 版：

public class Demo02 {
    public static void main(String[] args) {
        Phone2 phone = new Phone2();
        new Thread(()->{
            phone.sms();
        },"A").start();
        new Thread(()->{
            phone.sms();
        },"B").start();

    }
}
class Phone2{
    Lock lock = new ReentrantLock();

    public void sms(){
        lock.lock();

        try {
            System.out.println(Thread.currentThread().getName()+" sms");
            call();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void call() {
        lock.lock();

        try {
            System.out.println(Thread.currentThread().getName()+" call");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

3、自旋锁

原子类中的自旋锁：
AtomicInteger . getAndIncrement();

    public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }

unsafe类：
    public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
		//自旋锁
        do {
            var5 = this.getIntVolatile(var1, var2);
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

        return var5;
    }

7、死锁

public class DeadLockDemo {
    public static void main(String[] args) {
        String lockA="A";
        String lockB="B";
        new Thread(new MyThread(lockA, lockB),"T1").start();
        new Thread(new MyThread(lockB, lockA),"T2").start();
    }
}
class MyThread implements Runnable{
    private String lockA;
    private String lockB;

    public MyThread(String lockA, String lockB) {
        this.lockA = lockA;
        this.lockB = lockB;
    }

    @Override
    public void run() {
        synchronized (lockA){
            System.out.println(Thread.currentThread().getName()+" "+lockA+" get "+lockB);
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lockB){
                System.out.println(Thread.currentThread().getName()+" "+lockB+" get "+lockA);
            }
        }
    }
}

在这里插入图片描述

猴子会跳舞
关注
Java的并发
hefrankeleyn的博客
02-23 455
Java的并发 文章目录Java的并发一、同步访问共享的可变数据1.1 关键词`synchronized`1.2 同步的概念（1）同步是一种互斥的方式（2）如果没有同步，一个线程的变化就不能被其他线程看到1.3 Java语言规范保证读或者写一个变量是原子的，除非这个变量的类型为long或者double1.4 千万不要使用`Thread.stop`方法1.5 除非读和写操作都被同步，否则无法保证同步...
JUC并发编程入门学习笔记（狂神说）
Free的午后
08-06 1171
因为热爱所以坚持，因为热爱所以等待。熬过漫长无戏可演的日子，终于换来了人生的春天，共勉！！！ 1. 什么是JUC JUC就是java.util.concurrent下面的类包，专门用于多线程的开发。 2. 线程和进程 进程是操作系统中的应用程序、是资源分配的基本单位，线程是用来执行具体的任务和功能，是CPU调度和分派的最小单位 一个进程往往可以包含多个线程，至少包含一个 1）进程 一个程序，QQ.EXE Music.EXE；数据+代码+pcb 一个进程可以包含多个线程，至少包含一个线..
深入JVM--Java内存模型
张姐姐聊编程
08-30 290
Java内存模型即Java Memory Model，简称JMM。JMM定义了Java 虚拟机(JVM)在计算机内存(RAM)中的工作方式。JVM是整个计算机虚拟模型，所以JMM是隶属于JVM的。
java并发
lhhhwudi的博客
05-18 338
一.java语言特性 1、跨平台/可移植性 这是Java的核心优势。Java在设计时就很注重移植和跨平台性。比如：Java的int永远都是32位。不像C++可能是16，32，可能是根据编译器厂商规定的变化。这样的话程序的移植就会非常麻烦。 2、安全性 Java适合于网络/分布式环境，为了达到这个目标，在安全性方面投入了很大的精力，使Java可以很容易构建防病毒，防篡改的系统。 3、面向对象 面向对象是一种程序设计技术，非常适合大型软件的设计和开发。由于C++为了照顾大量C语言使用者而兼容了C，使
关于Java并发编程的总结和思考
热门推荐
骆昊的技术专栏
03-27 15万+
编写优质的并发代码是一件难度极高的事情。Java语言从第一版本开始内置了对多线程的支持，这一点在当年是非常了不起的，但是当我们对并发编程有了更深刻的认识和更多的实践后，实现并发编程就有了更多的方案和更好的选择。本文是对并发编程的一点总结和思考，同时也分享了Java 5以后的版本中如何编写并发代码的一点点经验。
Java并发
zheyangyebuxingaaa的博客
12-11 308
这是关于Java并发的概述，来自Java文档
JUC并发编程.md
01-28
### JUC并发编程知识点 #### 一、JUC并发编程简介 JUC（Java Util Concurrency）是Java标准库中的一个子包，提供了一系列高级并发工具类和接口，旨在简化多线程编程的复杂性。它包括了各种锁机制、线程池、信号量...
基于《狂神说Java》JUC并发编程--学习笔记
wudidahuanggua的博客
06-15 868
本笔记仅做学习与复习使用，不存在刻意抄袭。给各位学友强烈推荐《遇见狂神说》他的整套Java学习路线使我获益匪浅！！!点击跳转至遇见狂神说哔哩哔哩首页如果你也是狂神的小迷弟，可以加我好友一起探讨学习。 ...
Java多线程进阶之JUC并发编程教程详解（狂神说学习笔记）
super_song的博客
05-01 1177
文章目录环境准备1.JUC 简介2.线程和进程线程和进行并发和并行线程的状态wait/sleep的区别3.Lock 锁（重点）Synchronized 传统的锁Lock锁synchronized 和 lock 锁的区别4.生产者和消费者问题Synchronized 版本JUC 版本5.八个有关锁的问题问题1：两个同步方法，先执行发短信还是打电话？问题2：如果发短信延迟2秒，谁先执行问题3 加上一个没有锁的普通方法，谁先执行问题4：两个对象，一个调用发短信，一个调用打电话，谁先执行问题5：原来的两个同步方法，
厚积薄发打卡Day49：狂神说Java之JUC并发编程＜CAS入门到“锁“小结＞(下)
COOLGWAYNE_TECH_BLOG
04-09 349
前言： 众所周知，B站是全中国最大的在线学习平台，此次学习打卡的教程来自【狂神说】与【寒食君】两位B站up主，欢迎大家一键三连???? 学习视频来源： 【狂神说Java】JUC并发编程最新版通俗易懂 寒食君：Java并发系列 博客回顾： Day26：狂神说Java之JUC并发编程＜代码+笔记＞（上） Day27：狂神说Java之JUC并发编程（中）——从 JMM 到 volatile 前置知识：学习JUC前需要对java的多线程有一定的掌握。 学习视频： 【狂神说Java】多线程详解 详细资
java多线程并发——锁
z958479的博客
05-10 665
文章目录几种锁类型Synchronized 同步锁Synchronized 作用范围自旋锁自旋锁的优缺点ReentrantLockReentrantLock 与 synchronized锁的用法乐观锁悲观锁 几种锁类型 Synchronized 同步锁 synchronized 它可以把任意一个非 NULL 的对象当作锁。属于独占式的悲观锁，同时属于可重入锁。 Synchronized 作用范围 ...
JUC并发编程（多线程进阶整理）
weixin_47701015的博客
06-12 1533
JUC并发编程 JUC就是java.utilconcurrent 包的工具类
JAVA的并发
deasec的博客
09-19 158
开发工具与关键技术：IDEAJava 撰写时间：2021/9/10 同步访问共享的可变数据 关键字synchronized可以保证在同一时刻，只有一个线程可以执行某一个方法，或某一个代码块。许多程序员把同步的概念仅仅理解为一种互斥的方式（mutual exclusion），即，当一个对象被一个线程修改的时候，可以阻止另一个线程观察到对象内部不一致的状态。按...
Java中的并发
...
03-09 295
并发 多线程程序在更低一层扩展了多任务的概念：单个程序看起来在同时完成多个任务。每个任务在一个线程中执行，线程是控制线程的简称。如果一个程序可以同时运行多个线程，则称这个程序是多线程的（multithreaded）。 多进程与多线程的本质区别在于每个进程拥有自己的一整套变量，而线程则共享数据。共享变量使线程之间的通信比进程之间的通信更有效、更容易。此外，在有些操作系统中，与进程相比较，线程更“轻量级”，创建、撤销一个线程比启动新进程的开销要小得多。 线程状态 线程可以有如下6种状态： New（新建） Ru
3. Java 并发
林中静月下仙的博客
07-29 850
CAS的全称为Compare-And-Swap，直译就是对比交换。是一条CPU的原子指令，其作用是让CPU先进行比较两个值是否相等，然后原子地更新某个位置的值，经过调查发现，其实现方式是基于硬件平台的汇编指令，就是说CAS是靠硬件实现的，JVM只是封装了汇编调用，那些AtomicInteger类便是使用了这些封装后的接口。简单解释CAS操作需要输入两个数值，一个旧值(期望操作前的值)和一个新值，在操作期间先比较下在旧值有没有发生变化，如果没有发生变化，才交换成新值，发生了变化则不交换。可重入互斥同步。...
狂神说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等，用于协调多个线程的执行。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值