Java中volatile理解

最新推荐文章于 2022-11-02 15:44:52 发布

@HarveyMr

最新推荐文章于 2022-11-02 15:44:52 发布

阅读量237

点赞数

分类专栏： java深入理解文章标签： java volatile

本文链接：https://blog.csdn.net/heyi12345/article/details/119330391

版权

java深入理解专栏收录该内容

13 篇文章 0 订阅

订阅专栏

一、volatile是什么？

volatile是Java虚拟机提供的轻量级的同步机制，具有可见性、禁止指令排序、不保证原子性的特征。

一旦一个共享变量（类的成员变量、类的静态成员变量）被 volatile 修饰之后，那么就具备了两层语义：

保证了不同线程对这个变量进行读取时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。 (volatile 解决了线程间共享变量的可见性问题)。
禁止进行指令重排序，阻止编译器对代码的优化。

要了解它的三大特性，要先了解JMM。

二、JMM理解

JMM是（Java内存模型）Java Memory Model的简称，是一种抽象概念并不真实存在，它描述的是一种规则或规范，通过规范定义了程序中各个变量（包括实例字段，静态字段和构成数组对象的元素）的访问方式。

由于JVM运行程序的实体是线程，而每个线程创建时JVM都会为其创建一个工作内存，工作内存是每个线程的私有数据区域，而Java内存模型中规定所有变量都存储到主内存，主内存是共享内存区域，所有线程都可以访问，但线程对变量的操作必须在工作内存中进行。

首先要将变量从主内存拷贝到自己的工作内存空间，然后对变量进行操作，操作完成后再将变量写回主内存，不能直接操作主内存中的变量，因此不同的线程间无法访问对方的工作内存，线程间的通信（传值）必须通过主内存来完成。

上面提到的概念主内存和工作内存：

主内存：就是计算机的内存。主要包括【本地方法区】和【堆】。

工作内存：当同时有三个线程同时访问student对象的age变量时，那么每个线程都会拷贝一份，到各自的工作内存。主要包括该线程私有的【栈】等。

JMM具有三大特性，可见性、原子性、有序性，使用volatile可保证可见性和有序性，不能保证原子性。

三、如何保证可见性？

用代码验证volatile的可见性：

#代码验证
package com.study.thread;

class AddNumber {
    volatile int number = 0;

    public void add() {
        this.number = 90 + this.number;
    }
}

public class VolatileDemo {
    public static void main(String[] args) {
        AddNumber addNumber = new AddNumber();
        new Thread(() -> {
            System.out.println(">>come in ");
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            addNumber.add();
            System.out.println(">>come out ");

        }, "1001").start();
        while (addNumber.number == 0) {

        }
        System.out.println(">>>" + addNumber.number);
    }
}
#如果加volatile运行结果
>>come in 
>>come out 
>>>90
    
如果不加volatile,main进程一直处于while循环中，运行结果如下  
>>come in 
>>come out

四、volatile不保证原子性

原子性是不可分割，完整型，也即某个线程正在做某个具体业务时，中间不可以被加塞或分割。需要整体完整，要么同时成功，要么同时失败。

volatile不保证原子性，为什么不保证原子性？因为多个线程A、B、C在工作内存中操作同一个主内存的变量值时，A会把工作内存中的计算结果刷新回主内存，而其他线程B可能会有纳秒级的时间差，导致其他线程B将工作内存中的计算结果刷新到主内存，覆盖了主内存中该变量值。

如何解决原子性的问题？

在方法上加上synchronized

public synchronized void addPlusPlus() {
    number ++;
}

引入synchronized关键字后，保证了该方法每次只能够一个线程进行访问和操作，保证最后输出的结果。

使用juc下atomicInteger

package com.study.thread;

import java.util.concurrent.atomic.AtomicInteger;

class AddNumber {
    volatile int number = 0;
    AtomicInteger atomicInteger = new AtomicInteger();
    public void add() {
        this.number = 1 + this.number;
    }
    public void AotmicAdd() {
        atomicInteger.getAndAdd(1);
    }
}

public class VolatileDemo {
    public static void main(String[] args) {
        AddNumber addNumber = new AddNumber();
        for (int i = 0; i < 200; i++) {
            new Thread(() -> {
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                addNumber.add();
                addNumber.AotmicAdd();

            }, "thread" + i).start();
        }

        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println("volatile不保证原子性>>>" + addNumber.number);
        System.out.println("AtomicInteger保证原子性>>>" + addNumber.atomicInteger);
    }
}
#输出结果
volatile不保证原子性>>>197
AtomicInteger保证原子性>>>200

五、Volatile禁止指令重排

计算机在执行程序时，为了提高性能，编译器和处理器常常会对指令重排，一般分为以下三种：

源代码 -> 编译器优化的重排 -> 指令并行的重排 -> 内存系统的重排 -> 最终执行指令。

多线程环境中线程交替执行，由于编译器优化重排的存在，两个线程中使用的变量能否保证一致性是无法确认的，结果无法预测。

举一个指令重排的例子

public void mySort() {
    int x = 11;    
    int y = 12;
    x = x + 5;
    y = x * x;
}

按照正常单线程环境，执行顺序是1234。

但是在多线程环境中，可能出现以下的顺序：2134、1324。

但是指令排序也是有限制的，例如3不能出现在1面前，因为3需要依赖步骤1的声明，存在数据依赖。

Volatile针对指令重排做了啥？

Volatile实现禁止指令重排优化，从而避免了多线程环境下程序出现乱序执行的现象。

首先了解一个概念，内存屏障（Memory Barrier）又称内存栅栏，是一个CPU指令，它的作用有两个：

保证特定操作的顺序
保证某些变量的内存可见性（利用该特性实现volatile的内存可见性）

在Volatile的写和读的时候，加入屏障，防止出现指令重排，线程安全获得保障。

六、Volatile的应用

单线程下的单例模式代码（懒汉，适用于单线程）

public class SingletonDemo {
    //用静态变量保存这个唯一的实例
    private static SingletonDemo instance = null;
    
    //构造器私有化
    private SingletonDemo() {
        
    }
    
    //提供一个静态方法，来获取实例对象
    public static SingletonDemo getInstance() {
        if (instance == null) {
            instance = new SingletonDemo();
        }
        return instance;
    }
}

单线程下创建出来的都是同一个对象。但是在多线程的环境下，我们通过SingletonDemo.getInstance() 获取到的对象，并不是同一个。

方法上引入synchronized

public synchronized static SingletonDemo getInstance() {
    if (instance == null) {
        instance = new SingletonDemo();
    }
    return instance;
}

但是synchronizaed属于重量级的同步机制，它只允许一个线程同时访问获取实例的方法，但是因此减低了并发性，因此采用的比较少。

2.引入DCL双端检锁机制

就是在进来、出去的时候，进行检测。

public static SingletonDemo getInstance() {
    if (instance == null) {
        synchronized (SingletonDemo.class) {
            if (instance == null) {
                instance = new SingletonDemo();
            }
        }
    }
    return instance;
}

但是DCL机制不一定是线程安全的，原因是因为有指令重排的存在，我们加入Volatile可以禁止指令重排。

private static volatile SingletonDemo instance = null;

原因在豫某一个线程执行到第一次检测，读取到instance不为null时，instance的引用对象可能还没有完成初始化。

instance = new SingletonDemo();可以分为3步完成（伪代码）

memory = allocate();//1.分配对象内存孔吉纳

instance(memory); //2初始化对象

instance = memory;//3设置instance指向刚分配的内存地址，此时instance!=null

步骤2和步骤3不存在数据依赖关系，而且重排前和重排后程序的执行结果在单线程中并没有改变，因此这种重排优化时允许的。

memory = allocate(); //分配对象内存空间

instance = memory;//3设置instance指向刚分配的内存地址，此时instance!=null，但是对象还没有初始化完成

instance(memory); //2初始化对象

所以当一条线程访问instance不为null时，由于instance实例未必已初始化完成，也就造成了线程安全问题

@HarveyMr

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java中volatile理解

目录一、volatile是什么？二、JMM理解三、如何保证可见性？四、volatile不保证原子性五、Volatile禁止指令重排六、Volatile的应用一、volatile是什么？volatile是Java虚拟机提供的轻量级的同步机制，具有可见性、禁止指令排序、不保证原子性的特征。一旦一个共享变量（类的成员变量、类的静态成员变量）被 volatile 修饰之后，那么就具备了两层语义：保证了不同线程对这个变量进行读取时的可见...
复制链接

扫一扫