volatile的学习

1.什么是volatile？

volatile 是jvm提供的轻量级的同步机制，它拥有三大特性：

（1）保证可见性
（2）不保证原子性
（3）禁止指令重排（有序性）

2.什么是JMM

JMM是Java Mermory Moudle java内存模型，是虚构出来的规则，并不真实存在。

2.1 JMM的特性

（1）可见性
（2）原子性
（3）有序性

2.2 JMM关于同步的规定

（1）线程解锁前，必须将共享变量的值刷新回驻内存

（2）线程加锁前，必须读取主内存的共享变量的最新值拷贝到自己的工作空间（栈空间）

（3）加锁解锁是同一把锁

由于JVM运行程序的实体是线程，而每个线程创建时JVM都会为其创建一个属于自己的工作内存，工作内存是每个线程私有的数据区域，而java内存模型中规定所有变量都存在主内存，主内存是共享内存区域，所有线程都可以访问，但线程对变量的操作（读取赋值等）都要在工作内存中进行，首先要将变量从主内存中拷贝到自己的工作内存中，然后对变量进行操作，操作完成后再将变量写回主内存，不能直接操作主内存中的变量，各个线程中的工作内存存储着主内存中变量的副本，不同的线程间无法访问对方的栈空间，线程的通信（传值）必须通过主内存来完成。
其简要的访问过程：

3.代码验证volatile的可见性

当不加volatile 关键字修饰时：

public class Tes {
    int number = 0;
    void updateValue() {
        this.number = 60;
    }
}
    /**
     * 验证volatile的可见性
     */
        class volatileDemo {

        public static void main(String args[]) {
            Tes tes = new Tes();
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName()+"\t come in");
                try {
                    // 暂停一会线程
                    TimeUnit.SECONDS.sleep(3);
                    tes.updateValue();
                    System.out.println(Thread.currentThread().getName()+"\t update value" + tes.number);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            },"线程A").start();

            // 第二个线程就是main线程

            while (tes.number == 0) {}

            System.out.println(Thread.currentThread().getName()+"\t 线程 over " + tes.number);
        }
    }

程序运行结果：

main线程进入死循环，最后一句输出不了

加上volatile关键字之后：

public class Tes {
    volatile int number = 0;
    void updateValue() {
        this.number = 60;
    }
}

运行结果：

4.验证volatile不保证原子性

public class Tes {
    volatile int number = 0;
    void updateValue() {
        this.number = 60;
    }

    void numAdd() {
        number++;
    }
}

for(int i = 0; i < 10 ; i++){
                new Thread(() -> {
                    for (int j = 0; j < 1000; j++) {
                        tes.numAdd();
                    }
                }, String.valueOf(1)).start();
            }

            while (Thread.activeCount() >2) {
                Thread.yield();
            }

            System.out.println(Thread.currentThread().getName() +" \t 结果：" + tes.number);

从运行结果得知：每次运行都得到的结都不一致，volatile 不能保证数据传输的完整性（不保证原子性）

4.1 为什么不能保证原子性？

因为num++是线程非安全的，在多线程的情况下，线程之间争夺资源，在将变量写回主内存时数据会丢失，导致计算结果不正确。

4.2 在不用synchronized 的情况下如何解决？

使用java.util.concurrent.atomic.AtomicInteger修饰变量，对变量操作，保证数据的原子性

5. volatile 禁止指令重排

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