volatile关键字

---

一、volatile是什么？

volatile是java语言中的一个关键字，是虚拟机提供的轻量级的同步机制

二、volatile三个特性：

1、保证可见性
2、不保证原子性
3、禁止指令重排

1、保证可见性

package com.xiang.Volatilepackage;

import java.util.concurrent.TimeUnit;

public class JMMDemo01 {
    // 不加 volatile  程序就会死循环！
    private volatile static int num = 0;
    public static void main(String[] args) throws InterruptedException {//main线程

        new Thread(()->{//线程1  对主内存的变化是不知道的
            while(num == 0){

            }
        }).start();


        TimeUnit.SECONDS.sleep(1);

        num = 1;

        System.out.println(num);
    }
}

2、不保证原子性

原子性：不可分割有原则

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

package com.xiang.Volatilepackage;


// volatile 不保证原子性
public class VDemo01 {
    // volatile 不保证原子性
    private volatile static int num = 0;

    public  static void add(){
        num++;
    }
    public static void main(String[] args) {

        //理论上num结果应该为 2 万
        for (int i=1; i<=20; i++){
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();
        }
        while(Thread.activeCount()>2){// main gc
            Thread.yield();
        }

        System.out.println(Thread.currentThread().getName()+"  "+ num);

    }
}

如果不加lock 和 synchronized，怎么样保证原子性；
使用原子类，解决 原子性问题

原子类为什么这么高级

package com.xiang.Volatilepackage;


import java.util.concurrent.atomic.AtomicInteger;

// volatile 不保证原子性
public class VDemo01 {
    // volatile 不保证原子性
    private volatile static AtomicInteger num = new AtomicInteger();

    public static void add(){
//        num++;//不是原子性操作
        num.getAndIncrement();// AtomicInteger + 1 方法  使用的是CAS

    }
    public static void main(String[] args) {

        //理论上num结果应该为 2 万
        for (int i=1; i<=20; i++){
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();
        }
        while(Thread.activeCount()>2){// main gc
            Thread.yield();
        }

        System.out.println(Thread.currentThread().getName()+"  "+ num);

    }
}

这些类的底层都直接和操作系统挂钩！在内存中修改值。Unsafe 类是一个很特殊的存在

指令重排

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

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

处理器在进行指令重排的时候，考虑：数据之间的依赖性！

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

我们所期望的：1234       重排后：2134  1324

可不可能是   4123 不可能

可能造成影响的结果：a b x y 这四个值默认都是0；

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

正常结果：x = 0;y = 0;但是可能由于指令重排

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

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

volatile 可以避免指令重排

内存屏障。CPU指令。作用：

1、保证特定的操作的执行顺序！

2、可以保证某些变量的内存可见性（利用这些特性volatile实现了可见性）

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

Volatile的另外一个作用是防止编译器为了提高速度将一个变量缓存到寄存器内而不写回

一个对象的赋值初始化过程分为三步：

• 分配内存
• 初始化构造函数
• 将内存地址赋值给变量

cpu的动态调度导致2、3步骤可能 执行顺序调换，这时候一个线程来调用对象时，就会传一个未完成构造的对象。