关于java:volatile的理解

问：谈谈对 volatile 的了解？

当用 volatile 去申明一个变量时，就等于通知虚拟机，这个变量极有可能会被某些程序或线程批改。为了确保这个变量批改后，利用范畴内所有线程都能晓得这个改变，虚拟机就要保障这个变量的可见性等特点。最简略的一种办法就是退出 volatile 关键字。

volatile是 JVM 提供的轻量级的同步机制。

volatile 有三大个性：

保障可见性
不保障原子性
禁止指令重排

要理解它的三大个性，要先理解 JMM。

因为 JVM 运行程序的实体是线程，而每个线程创立时 JVM 都会为其创立一个工作内存， 工作内存是每个线程的公有数据区域 ，而 Java 内存模型中规定所有变量都存储到主内存， 主内存是共享内存区域，所有线程都能够拜访，但线程对变量的操作必须在工作内存中进行。
首先要将变量从主内存拷贝到本人的工作内存空间，而后对变量进行操作，操作实现后再将变量写回主内存，不能间接操作主内存中的变量，因而不同的线程间无法访问对方的工作内存，线程间的通信（传值）必须通过主内存来实现。

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

主内存：就是计算机的内存。次要包含【本地办法区】和【堆】。
工作内存：当同时有三个线程同时拜访 student 对象的 age 变量时，那么每个线程都会拷贝一份，到各自的工作内存。次要包含该线程公有的【栈】等。

用代码验证 volatile 的可见性：

class MyData {
    // 定义 int 变量
    int number = 0;

    // 增加办法把变量 批改为 60
    public void addTo60() {this.number = 60;}
}

public class Test {public static void main(String[] args) {
        // 资源类
        MyData myData = new MyData();
        // 用 lambda 表达式创立线程
        new Thread(() -> {System.out.println("线程进来了");

            // 线程睡眠三秒，假如在进行运算
            try {Thread.sleep(3000);
            } catch (InterruptedException e) {e.printStackTrace();
            }

            // 批改 number 的值
            myData.addTo60();
            // 输入批改后的值
            System.out.println("线程更新了 number 的值为" + myData.number);
        }).start();

        // main 线程就始终在这里期待循环，直到 number 的值不等于零
        while (myData.number == 0) { }
        
        // 最初输入这句话，看是否跳出了上一个循环
        System.out.println("main 办法完结了");
    }
}

最初线程没有进行，没有输入 main 办法完结了 这句话，阐明没有用 volatile 润饰的变量，是没有可见性的。

当咱们给变量 number 增加 volatile 关键字润饰时，发现能够胜利输入完结语句。

volatile 润饰的关键字，是为了减少 主线程和线程之间的可见性，只有有一个线程批改了内存中的值，其它线程也能马上感知，是具备 JVM 轻量级同步机制的。

volatile 保障可见性用到了 总线嗅探技术。
总线嗅探技术有哪些毛病：
- 因为 Volatile 的 MESI 缓存一致性协定，须要一直的从主内存嗅探和 CAS 循环，有效的交互会导致总线带宽达到峰值。因而不要大量应用 volatile 关键字，依据理论利用场景抉择。

不可分割，完整性。也就是说某个线程正在做某个具体业务时，两头不能够被加塞或者被宰割，须要具体实现，要么同时胜利，要么同时失败。

class MyData {
    // 定义 int 变量
    volatile int number = 0;

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

public class Test {public static void main(String[] args) {MyData myData = new MyData();

        // 创立 20 个线程，线程外面进行 1000 次循环（20*1000=20000）for (int i = 0; i < 20; i++) {new Thread(() -> {for (int j = 0; j < 1000; j++) {myData.addPlusPlus();
                }

            }).start();}

    /* 
        须要期待下面 20 个线程都执行结束后，再用 main 线程获得最终的后果
        这里判断线程数是否大于 2，为什么是 2？因为默认有两个线程的，一个 main 线程，一个 gc 线程
    */
        while (Thread.activeCount() > 2) {Thread.yield(); // yield 示意不执行
        }

        System.out.println("线程运行完后，number 的值为：" + myData.number);
    }
}

线程执行结束后，number 输入的值并没有 20000，而是每次运行的后果都不统一，这阐明了 volatile 润饰的变量不保障原子性。

当线程 A 和线程 B 同时批改各自工作空间里的内容，因为可见性，须要将批改的值写入主内存。这就导致多个线程呈现同时写入的状况，线程 A 写的时候，线程 B 也在写入，导致其中的一个线程被挂起，其中一个线程笼罩了另一个线程的值，造成了数据的失落。

i++ 不是原子操作，其执行要分为三步：

读内存到寄存器
在寄存器内自增
写回内存

举个例子：当初有 A、B 两个线程，i 初始为 2。A 线程实现第二步的加一操作后，被切换到 B 线程，B 线程中执行完这三步后，再切换回来。此时 A 寄存器中的 i=3 写回内存，最初 i 的值不是失常的 4。

在办法上加上synchronized

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

引入 synchronized 关键字后，保障了该办法每次只可能一个线程进行拜访和操作，保障最初输入的后果。

AtomicInteger

咱们还能够应用 JUC 上面的 原子包装类 ，i++ 能够应用 AtomicInteger 来代替

// 创立一个原子 Integer 包装类，默认为 0
AtomicInteger number = new AtomicInteger();

public void addAtomic(){number.getAndIncrement();    // 相当于 number++
}

计算机在执行程序时，为了进步性能，编译器和处理器经常会对指令重排，个别分为以下三种：

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

多线程环境中线程交替执行，因为编译器优化重排的存在，两个线程中应用的变量是否保障一致性是无奈确认的，后果无奈预测。

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

依照失常单线程环境，执行程序是 1234。

然而在多线程环境中，可能呈现以下的程序：2134、1324。

然而指令排序也是有限度的，例如 3 不能呈现在 1 背后，因为 3 须要依赖步骤 1 的申明，存在数据依赖。

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

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

保障特定操作的程序
保障某些变量的内存可见性（利用该个性实现 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() 获取到的对象，并不是同一个。

1、办法上引入 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 的获取能够分为三步进行实现：

调配对象内存空间
初始化对象
设置 instance 指向刚刚调配的内存地址，此时instance != null

因为步骤 2、3 不存在数据依赖，即可能呈现第三步先于第二步执行；此时因为曾经给行将创立的 instance 调配了内存空间，所以 instance！=null，但对象的初始化还未实现，造成了线程的平安问题。

关于java:volatile的理解

JMM——Java 内存模型

如何保障可见性？

Volatile 不保障原子性

什么是原子性？

代码证实 volatile 不保障原子性

为什么会呈现数据失落？

i++ 是原子操作吗？

如果解决原子性的问题？

Volatile 禁止指令重排

举一个指令重排的例子

Volatile 针对指令重排做了啥？

Volatile 的利用