为什么要有volatile？volatile的三大特性是什么？

我们知道，在Java的内存模型中每个线程有⾃⼰的⼯作内存，同时还有⼀个共享的主内存。
举个例⼦，⽐如说有两个线程，他们的代码⾥都需要读取 data 这个变量的值，那么他们都会从主内存⾥加载 data 变量的值到⾃⼰的⼯作内存，然后才可以使⽤那个值。

如上图中所示，每个线程都把 data 这个变量的副本加载到了⾃⼰的⼯作内存⾥了，但是这样会存在一个问题，当线程1更改data值为1，主内存的值还是0，线程2读到的还是0.这时候就该volatile登场了，当给这个data变量加上volatile修饰时，就可以完美的解决线程间可见性的问题。当线程1修改data的值时，会将数据刷到主内存，并且会将其他线程的缓存副本失效，不能使用。需要再次去主内存读取最新的数据。

volatile三大特性

• 保证可见性
• 不保证原子性
• 禁止指令重排(有序性)

可见性：

每个线程创建时JVM都会为他创建一个工作内存，工作内存是每个线程的私有数据区域，Java内存模型中所有的变量都存在主内存，线程对变量的读取和赋值都要在工作内存中完成。所以首先要将变量拷贝到工作内存，修改后再写回主内存，如果有多个线程都读取了这个变量。修改后则需要通知那些线程。这个通知的行为便成为可见性。详见下图。

volatile可见性验证

/**
 * 1.验证volatile的可见性
 *  1.1 假如int number = 0; number变量之前没有加volatile关键字修饰
 *  1.2 添加了volatile，可以解决可见性问题
 **/
public class VolatileDemo {
    public static void main(String[] args) {
        MyData myData = new MyData();
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName()+"\t come in");

            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            myData.addTo60();
            System.out.println(Thread.currentThread().getName() + "\t update number value:" + myData.number);

        }, "AAA").start();

        while (myData.number == 0) {
            //main线程一直在等待循环，直到number不等于0
        }

        System.out.println(Thread.currentThread().getName()+"\t mission is over");
    }
}

class MyData{
    int number = 0;
    public void addTo60(){
        this.number = 60;
    }
}

运行结束，AAA线程已经将工作内存中的number改为60，并且更新到了主内存，main线程却获取不到。

当number采用volatile修饰时，main便能访问。证明了volatile的可见性

volatile int number = 0;

不保证原子性：

volatile不保证原子性验证

public class VolatileDemo {
    public static void main(String[] args) {
        MyData myData = new MyData();
        for (int i = 1; i <= 20; i++) {
            new Thread(() -> {
                for (int j = 1; j <= 1000; j++) {
                    myData.addPlusPlus();
                }
            }, String.valueOf(i)).start();
        }

        //需要等待上面20个线程都是计算完成，然后main线程取得结果
        while (Thread.activeCount() > 2) {//2是因为有main线程和GC线程
            Thread.yield();//main线程把自己的cpu执行的时间让掉
        }
        System.out.println(Thread.currentThread().getName() + "\t finally number value:" +myData.number);
    }
}

class MyData{
    volatile int number = 0;
    public void addPlusPlus(){
        number++;
    }
}

正常应该是20000.多次验证这里都是小于20000.证明了每个线程去访问这个变量并不是原子的
可以采用AtomicInteger来保证原子性

禁止指令重排

单线程没有指令重排，多线程才会有

指令重排不能说好与不好，根据实际的业务场景来决定是否指令重排。指令重排会导致数据不一致