做网站需要哪些证书,大学生网页设计作业,淘宝单页面网站,手机个人网站制作教程volatile 关键字 1. 保证内存可见性2. 禁止指令重排序3. 不保证原子性 1. 保证内存可见性
内存可见性问题: 一个线程针对一个变量进行读取操作#xff0c;另一个线程针对这个变量进行修改操作#xff0c;
此时读到的值#xff0c;不一定是修改后的值#xff0c;即这个读线… volatile 关键字 1. 保证内存可见性2. 禁止指令重排序3. 不保证原子性 1. 保证内存可见性
内存可见性问题: 一个线程针对一个变量进行读取操作另一个线程针对这个变量进行修改操作
此时读到的值不一定是修改后的值即这个读线程没有感知到变量的变化。volatile 修饰的变量, 能够保证 “内存可见性”. 代码在写入 volatile 修饰的变量的时候,
改变线程工作内存寄存器中volatile变量副本的值将改变后的副本的值从工作内存刷新到主内存内存
代码在读取 volatile 修饰的变量的时候
从主内存内存中读取volatile变量的最新值到线程的工作内存寄存器中从工作内存寄存器中读取volatile变量的副本
加上 volatile , 强制读写内存. 速度是慢了, 但是数据变的更准确了.
代码示例
class SynchronizedBlockExample {static class Counter {
// public volatile int flag 0;public int flag 0;}public static void main(String[] args) {Counter counter new Counter();Thread t1 new Thread(() - {while (counter.flag 0) {// do nothing}System.out.println(循环结束!);});Thread t2 new Thread(() - {Scanner scanner new Scanner(System.in);System.out.println(输入一个整数:);counter.flag scanner.nextInt();});t1.start();t2.start();}
}while 循环里面 counter.flag 0, 里面有 两步操作并且线程启动之后一直在快速循环判断
load把内存中 flag 的值读到寄存器里面cmp把寄存器里面的值和 0 比较大小
上述循环执行非常快1s 执行百万次以上。 但是循环这么多次在 t2 修改之前 load 很多次发现值都一样 而 load 相对于 cmp 慢很多load 是从内存中读取数据cmp 是在寄存器里面进行比较再加上多次 load 的结果都一样 所以编译器就做了一个大胆的想法不再真正的 load 了既然都一样好像没人改那就不从 内存中读取了直接从 寄存器里面读取。 所以当我们输入一个非零值时由于编译器还是从寄存器里面读取而不是读内存所以线程 t1 无法立即感知到。
当你输入一个 非 0 值时如果不加上 volatile , 线程 t1 无法及时感知到 加上 volatile线程 t1 被强制读取内存能立马感知到 flag 被赋予 非 0 值会立即退出循环。 归根结底还是编译器进行优化是发生了误判但是这个什么时候优化又比较 “玄学” 可能多加上一行代码可能就不优化了所以稳妥的方法还是该加 volatile 的地方都加上。
2. 禁止指令重排序
什么是指令重排序 举个栗子 一段代码是这样的
1. 去前台取下 U 盘
2. 去教室写 10 分钟作业
3. 去前台取下快递为了提高效率, JVM、CPU指令集会对其进行优化比如按 1-3-2的方式执行也是没问题可以少跑一次前台提高效率。这种就叫做指令重排序。
编译器对于指令重排序的前提是 “保持逻辑不发生变化”. 这一点在单线程环境下比较容易判断, 但是在多线程环境下就没那么容易了, 多线程的代码执行复杂程度更高, 编译器很难在编译阶段对代码的执行效果进行预测, 因此激进的重排序很容易导致优化后的逻辑和之前不等价.
代码举例: 线程安全的单例模式:
class Singleton {// 使用 volatile 防止指令重排序private static volatile Singleton instance null; // 使用 static, 该实例就是该类的唯一实例// 私有化构造方法, 防止在类外创造实例private Singleton(){}public static Singleton getSingleton() {// 判断是否需要加锁if (instance null) {synchronized (Singleton.class) { // 针对类对象加锁, 保证所有线程都是针对同一个对象加锁// 判断是否需要创建实例if (instance null) {instance new Singleton();}}}return instance;}
}对于上面这个代码, 就是一个单例模式, 只有一个 Singleton 实例, 并且只能通过 getSingleton 方法获得。
获得实例的步骤是
判断实例是否为空以此来决定是否要加锁。因为 代码块里面是 先判断是否为空再创建对象这是两个步骤所以要加锁。实例为 null, 就创建实例。返回实例。
其中创建实例 new Singleton() 又分为 三个步骤
分配内存空间对内存空间进行初始化把内存空间的地址赋给引用
假如没有使用 volatile 关键字编译器可能对此进行了优化进行了指令重排序那么有可能优化为 1 - 3 - 2 。
这样的话当第一个线程 t1 要获取实例时因为实例为null, 所以肯定会创建实例但是可能编译器进行了优化那么可能顺序就变成了 1 - 3 - 2
先开辟了一块空间将空间地址赋值给引用对空间初始化
当进行完第二步把空间地址赋值给引用后还没来得及初始化此时另外一个线程 t2 来获取实例了 进行判断时发现 instance 不为空那么就直接返回实例了
t2 拿到实例后直接进行使用那么就会报错了因为虽然开辟了空间但是 t1 还没来得及对空间进行初始化所以访问的是非法的地址。
解决 对 instance 对象加上 volatile 关键字禁止指令重排序。
3. 不保证原子性
volatile 和 synchronized 有着本质的区别. synchronized 能够保证原子性和内存可见性 volatile 保证的是内存可见性以及禁止指令重排序。
class SynchronizedBlockExample {static class Counter {volatile public int count 0;void increase() {count;}}public static void main(String[] args) throws InterruptedException {final Counter counter new Counter();Thread t1 new Thread(() - {for (int i 0; i 50000; i) {counter.increase();}});Thread t2 new Thread(() - {for (int i 0; i 50000; i) {counter.increase();}});t1.start();t2.start();t1.join();t2.join();System.out.println(counter.count);}
}给 count 加上 volatile 关键字最终 count 的值仍然无法保证是 100000。
但是使用 synchronized 的话就能保证原子性。使得代码执行结果符合预期。
class SynchronizedBlockExample {static class Counter {public int count 0;synchronized void increase() {count;}}public static void main(String[] args) throws InterruptedException {final Counter counter new Counter();Thread t1 new Thread(() - {for (int i 0; i 50000; i) {counter.increase();}});Thread t2 new Thread(() - {for (int i 0; i 50000; i) {counter.increase();}});t1.start();t2.start();t1.join();t2.join();System.out.println(counter.count);}
}好啦 以上就是对 volatile 的讲解希望能帮到你 评论区欢迎指正 !
