volatile关键字

以前觉得对 volatile很熟悉，突然发现 不太能很准确的 在 什么场景中需要使用 volatile。于是 记录一下：

第一：可见性

可见性主要解决的是，由于 java内存模型，分 主内存 和工作内存，线程 都是 从 主内存中 获取数据到 工作内存后 再使用数据的。 如果 线程 读取了 主内存的数据到工作内存后，使用的过程中，主内存的数据被修改了，那当前这个线程 是否可以拿到主内存中的最新值，就volatile决定的。一个关键的事情是，使用的过程中，分两中：

1. 使用前，如果主内存数据变了，那么 会及时更新最新值到工作内存

2.使用后，如果已经使用过了，当前线程也不会再使用这个变量了，那么 全凭运气了，因为及时 更新了最新值，也不用了啊。        

另外一点是，如果 变量 在 synchronized 语句块内，则 看情况 也可以不用 volatile修饰

第二：防止指令重排序

1. 对象实例化

2. 变量赋值 需要按照指定顺序

示例如下：

public class VolatileTest {

    /**
     * 只保证可见性，不保证原子性
     */
    private static volatile   int i = 0;
    private static  boolean adder1Start = false;

    public static void main(String[] args) throws Exception{

        CountDownLatch countDownLatch = new CountDownLatch(2);
        new Thread(()->{
            while (true){
                /**
                 * 如果当前线程先启动，静态变量 adder1Start ，如果不用  volatile 修饰，则 这里 执行不下去
                 *
                 * 所以 不管是 成员变量 还是 静态变量，都需要加 volatile 保证可见性
                 */

                 // 如果 不使用 volatile 修饰 adder1Start，但是 把 synchronized 语句块包一下，就OK 了。
                // synchronized 关键字 也保证 可见性，每次读取最新的数据
//                synchronized (VolatileTest.class) {
                    if (adder1Start){
                        /**
                         * 当前线程启动后，由于 adder1Start 为false,所以，在 adder1Start 为true之前
                         * 会不断的循环 读取 adder1Start 值。
                         *
                         * 如果 adder1Start 没有 使用 volatile修饰，那么 adder1Start 每次都是用的 当前线程栈空间的数据。
                         * 如果 adder1Start 使用 volatile修饰，那么 adder1Start 每次 都是用的 主内存中 最新的数据。
                         * 这就是 volatile 的 内存 可见性。
                         *
                         * 同时，volatile 还有 防止 指令重排序的功能。
                         *
                         * 对于 内存可见性 和 防止指令重排序，需要 根据 实际使用场景 来判断，以判断 是否需要 使用 volatile 关键字。
                         *
                         * 另外， volatile 不保证 原子性，原子性是针对 指令的，多指令操作，需要用同步锁。
                         *
                         * 如果 变量在 synchronize 语句块内，则 可以不用 volatile修饰，因为 synchronize 保证 可见、重排、原子三个特性
                         *
                         */
                        for (int k=0;k<100000;k++){
                            i++;
                        }
                        countDownLatch.countDown();
                        break;
                    }
//                }
            }
        },"adder2").start();

        try {
            Thread.sleep(2 * 1000);
        }catch (Exception e){
            System.out.printf("",e);
        }
        new Thread(()->{
            adder1Start = true;
            for (int k=0;k<100000;k++){
                i++;
            }
            countDownLatch.countDown();
        },"adder1").start();
        
        countDownLatch.await();
        System.out.printf("i:" + i);
    }
}