深入Volatile

深入Volatile

1、变量不可见性:

1.1多线程下变量的不可见性

直接上代码

java 复制代码
/**
 * @author yourkin666
 * @date 2024/08/12/16:12
 * @description
 */
public class h1 {
    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        myClass.start();

        while (true) {
            if (myClass.isFlag()) {
                System.out.println("circle!!!");
            }
        }
    }

}
class MyClass extends Thread{
    private boolean flag = false;
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        flag = true;
        System.out.println("flag = "+ flag);
    }

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}

子线程从主内存中读取数据放到工作内存,将flag修改为true,但是此时flag的值还没有写回主内存,所以主线程读取的flag依然是false

当子线程将flag值写回主内存后,main函数里面的while(true)调用的是系统比较底层的代码,速度较快,没时间再去主存中读取flag

所以while(true)读取到的值一直是false(当然主线程可能在一个时刻去主内存读取最新的值,我们无法控制)

1.2变量不可见性内存语义

JMM(java内存模型)是针对于Java并发编程的模型

JMM规范

  • 所有共享变量(实例变量和类变量)都存在于主内存,不包含局部变量,因为局部变量是线程私有
  • 每一个线程都还有自己的工作内存,在工作内存中,保存了一份共享变量的副本
  • 线程对变量的所有操作都在工作内存中完成
  • 不同线程的工作内存是隔离的

可见性问题的原因

  • 所有共享变量都存在于主内存,每个线程都有自己的工作内存,而且线程读写共享数据也是通过本地内存交换的,所以导致了可见性问题
1.3变量不可见行的解决方案

​ 第一种是加锁

​ 第二种是使用volatile关键字

加锁:

java 复制代码
while (true) {
            synchronized (myClass) {
            if (myClass.isFlag()) {
                System.out.println("circle!!!");
            }
       }
}

线程进入synchronized代码块前后的执行过程:

  1. 线程获得锁
  2. 清空工作内存
  3. 从主内存拷贝共享变量的最新值
  4. 执行代码块
  5. 将修改后的副本的值刷新回主内存中
  6. 线程释放锁

volatile关键字:

java 复制代码
    private volatile boolean flag = false;

工作原理:

  1. 子线程从主内存读取数据放在工作内存,修改flag值后,还没有写回主内存
  2. 此时主线程读取到了flag值为false
  3. 当子线程将flag写回主线程后,就失效工作内存中的拷贝值
  4. 再次对flag进行操作时,线程会从主内存读取最新值,放入工作内存

volatile 关键字保证不同线程对共享变量操作的可见性,也就是一个线程修改了volatile 修饰的变量,当此变量写回 主内存,其他线程可以立即看到最新值

volatile修饰的变量可以在多线程并发修改下,实现线程间变量的可见性

2、volatile其他特性:

1.volatile不保证原子性
java 复制代码
/**
 * @author yourkin666
 * @date 2024/08/12/16:12
 * @description
 */
public class h1 {
    public static void main(String[] args) {
        Runnable myClass = new MyClass();
        for (int i = 1; i <= 100 ; i++) {
            new Thread(myClass).start();
        }

    }
}
class MyClass implements Runnable{
    private volatile int count = 0;
    @Override
    public void run() {
      for (int i = 1; i <= 10000; i++) {
          count++;
          System.out.println("count >>>>" + count);
      }
    }
}

count++是非原子操作,起码可以被分为三步

在多线程环境下,volatile修饰的变量也是线程不安全的

要保证数据的安全性,还得是 ,或者原子类

原子类:

​ java.util.concurrent.atomic(Atomic包)

​ 这个包中的原子操作类提供一种用法简单、性能高效、 线程安全地更新一个变量的方式

AtomicInteger:

原子型Integer ,可以实现原子更新操作:

java 复制代码
public AtomicInter()
初始化一个默认值为0的原子型Integet    
public AtomicInter(int initialValue)
初始化一个指定值的原子型Integet
int get()
获取值    
int getAndIncrement() 
以原子方式将当前值加1,返回自增前的值
int incrementAndget() 
以原子方式将当前值加1,返回自增后的值
int addAndGet(int data)
以原子方式将输入的值与AtomicInteger里的value相加,并返回结果
int getAndSet(int value)
以原子方式设置newValue的值,并返回旧值             
2.禁止指令重排序

为了提升程序的运行效率,编译器和处理器常常对指令进行重排序

使用volatile可以禁止指令重排序,从而修正重排序可能带来的并发安全问题

3、volatile内存语义:

volatile写读建立的happens - before关系:

从JDK5开始,提出happens - before概念,来阐述操作之间的内存可见性。

如果一个操作的结果需要对另一个操作可见,那么这两个操作之间必须存在happens - before关系。(这里提到的两个操作既可以是在一个线程中,也可以是不同线程之间

happens - before规则:
  • 单线程规则

    同一个线程中,前面的所有写操作对后面的操作可见

  • 锁规则(synchronized、Lock等)

    如果线程1解锁了monitor A ,接着线程2锁定了A,那么,线程1解锁A之前的写操作都对线程2可见

  • volatile变量规则

    如果线程1写入volatile变量v(临界资源),接着线程2读取了v,那么,线程1写入v及之前的写操作都是对线程2可见的

  • 传递性

    A对B可见,B对C可见,那么A对C可见

  • start()规则

    假设线程A在执行过程中,通过执行ThreadB.start()来启动线程B,那么线程A在线程B执行前对共享变量的修改,是对线程B可见(线程B启动后的,线程A对变量的修改,线程B就未必看得到了

  • join()规则

    线程t1写入的所有变量,在任意其他线程t2调用t1.join(),或者t1.isAlive()成功返回后,都对t2可见

4、volatile相关面试题:

相关推荐
憨子周1 小时前
2M的带宽怎么怎么设置tcp滑动窗口以及连接池
java·网络·网络协议·tcp/ip
阿斯卡码1 小时前
jupyter添加、删除、查看内核
ide·python·jupyter
霖雨2 小时前
使用Visual Studio Code 快速新建Net项目
java·ide·windows·vscode·编辑器
SRY122404192 小时前
javaSE面试题
java·开发语言·面试
Fiercezm3 小时前
JUC学习
java
无尽的大道3 小时前
Java 泛型详解:参数化类型的强大之处
java·开发语言
ZIM学编程3 小时前
Java基础Day-Sixteen
java·开发语言·windows
我不是星海3 小时前
1.集合体系补充(1)
java·数据结构
P.H. Infinity3 小时前
【RabbitMQ】07-业务幂等处理
java·rabbitmq·java-rabbitmq
爱吃土豆的程序员3 小时前
java XMLStreamConstants.CDATA 无法识别 <![CDATA[]]>
xml·java·cdata