JUC并发编程学习笔记（十六）Volatile

合集 - JUC并发编程(20)

1.JUC并发编程学习笔记（二）Lock锁(重点)2023-11-022.JUC并发编程学习笔记（一）认知进程和线程2023-11-023.JUC并发编程学习笔记（三）生产者和消费者问题2023-11-024.JUC并发编程学习笔记（四）8锁现象2023-11-025.JUC并发编程学习（五）集合类不安全2023-11-036.JUC并发编程学习笔记（六）Callable(简单)2023-11-037.JUC并发编程学习笔记（七）常用的辅助类2023-11-048.JUC并发编程学习笔记（八）读写锁2023-11-049.JUC并发编程学习笔记（九）阻塞队列2023-11-0410.JUC并发编程学习笔记（十）线程池（重点）2023-11-0411.JUC并发编程学习（十一）四大函数式接口（必备）2023-11-0512.JUC并发编程学习笔记（十二）Stream流式计算2023-11-0513.JUC并发编程学习（十三）ForkJoin2023-11-0614.JUC并发编程学习笔记（十四）异步回调2023-11-0615.JUC并发编程学习笔记（十五）JMM2023-11-0716.JUC并发编程学习笔记（十七）彻底玩转单例模式2023-11-0917.JUC并发编程学习笔记（十九）原子引用2023-11-1418.JUC并发编程（终章）各种锁的理解2023-11-16

19.JUC并发编程学习笔记（十六）Volatile2023-11-08

20.JUC并发编程学习笔记（十八）深入理解CAS2023-11-10

收起

Volatile

保证可见性

private volatile static Integer num = 0;

使用了volatile关键字，即可保证它本身可被其他线程的工作内存感知，即变化时也会被同步变化。

不保证原子性

原子性：不可分割

线程A在执行任务时是不可被打扰的，也不能被分割，要么同时成功，要么同时失败。

package org.example.tvolatile;
 
public class VDemo02 {
    //synchronized保证原子性，每次只有一条线程执行，所以结果准确
    //volatile不保证原子性，虽然也是同步机制，但是结果不准确
    private volatile static int num = 0;
    public static void add(){
        num++;
    }
    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){//主线程和GC线程
            Thread.yield();//让主线程礼让
        }
        System.out.println(num);
    }
 
}

每次结果也不一样。

如果不加Lock加synchronized，怎么保证原子性?

要了解为什么一个num++都不能保证原子性，首先我们需要查看到他编译好的class字节码文件，找到target，并且右键选择打开外部的文件，找到对应的class文件，再通过javap -c命令反编译查看字节码文件。

查看到字节码文件后可以看到从底层看，其实num++这个操作再多线程下并不安全，有获取和写回这两个操作

那么又回到了这个问题，在volatile中如何保证原子性。打开jdk帮助文档，我们能找到原子性的一些数据类型

在volatile需要保证原子性操作的时候使用原子类来解决原子问题。

原子类为什么高级

原子类的包装类底层使用的是CAS操作。

package org.example.tvolatile;
 
import java.util.concurrent.atomic.AtomicInteger;
 
public class VDemo02 {
    //synchronized保证原子性，每次只有一条线程执行，所以结果准确
    //volatile不保证原子性，虽然也是同步机制，但是结果不准确
    private volatile static AtomicInteger num = new AtomicInteger(0);
    public static void add(){
        num.getAndIncrement();//AtomicInteger+1的方法，并不是简单的+1操作，方法：CAS
    }
    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){//主线程和GC线程
            Thread.yield();//让主线程礼让
        }
        System.out.println(num);
    }
 
}

这些类的底层都直接调用c++和操作系统挂钩！在内存中修改值。Unsafe类是一个很特殊的存在！Unsafe类的所有方法都是native方法，调用c++底层

native是与C++联合开发的时候用的！java自己开发不用的！

禁止指令重排

什么是指令重排：你写的程序并不是按照你写的那样去执行的

源代码-----编译器优化的指令重排--------指令并行也可能会指令重排--------内存系统也会重排--------->执行

int x = 1;//1
int y = 2;//2
x = x+5;//3
y = x*x;//4
 

我们所期望的执行顺序：1、2、3、4;但是如果按照1、3、2、4或者2、4、1、3的顺序执行也是能够顺利运行的，计算机执行时可能对对我们所期望执行顺序的程序进行指令重排，结果是正确的但是对运行顺序有所不同

但是指令重排后的顺序不可能是4、3、2、1或者其它不符合逻辑的顺序。因为处理器在进行指令重拍的过程中会考虑数据之间的依赖性

可能造成影响的结果：四个初始值都为零

线程A	线程B
x = a;	y = b;
b = 1;	a = 2;

由于两个线程的操作都没有数据依赖性，指令重排就不会考虑顺序问题，可能会导致最终的执行顺序如下

线程A	线程B
b = 1;	a = 2;
x = a;	y = b；

多线程下可能导致一些问题

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

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

这是一种概念可能你写1000w行代码都不一定会出现，但是在理论上是一定会参数的。

volatile可以避免指令重排

计算机中存在着一种指令叫做内存屏障，它是一种CPU指令。

作用：

1、保证特定操作的执行顺序（可以让volatile避免指令重排）

2、可以保证某些变量的内存可见性（可以让volatile实现可见性）

Volatile保证可见性、不能保证原子性、由于内存屏障，可以避免指令重排的现象产生！

内存屏障在单例模式中使用的最多！