volatile原理分析

volatile原理分析：

一：代码实例（不加volatile）：

  static  boolean initFlag=false;
    public static void main(String[] args) throws InterruptedException {
    
    

        new Thread(new Runnable() {
    
    
            @Override
            public void run() {
    
    
                while (!initFlag){
    
    

                }
                System.out.println("success");
            }
        }).start();
        Thread.sleep(2000);

        new Thread(new Runnable() {
    
    
            @Override
            public void run() {
    
    
                System.out.println("准备数据");
                initFlag=true;
                System.out.println("数据处理完成");
            }
        }).start();

    }

执行效果：
在这里插入图片描述

循环未结束，未打印success

二：对变量initFlag加上volatile

static volatile boolean initFlag=false;

执行效果：
在这里插入图片描述

原理分析：
在这里插入图片描述

说明：
如果不加volatile：因为都是将主内存的数据读入工作内存，操作完之后写回主内存，可能线程1读取的是，线程2修改了，但是没有更新到主内存的值。所以success不会打印

如果加volatile：会有一个主线嗅探机制，当线程2运行的结构写回主内存的时候（store，write）会对主内存的initFlag变量加锁lock，写入后unlock。经过总线时其他引用了initflag变量的线程都会让自己的工作内存变量失效，重新从主内存读入initFlag的值。

三：注意点：volatile并不能保证原子性，可以禁止指令重排序

禁止重排序：

public class Singleton {
    
    
 
    private volatile static Singleton instance;
 
    private Singleton() {
    
    }
 
    public static Singleton getInstance() {
    
    
        if (instance == null) {
    
    
            synchronized (Singleton.class) {
    
    
                if (instance == null) {
    
    
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

说明：instance = new Singleton() 不是原子操作，是三个阶段：

为instance分配内存
初始化instance
将instance变量指向分配的内存空间
如果重排序的话，2.3可能颠倒，那么会返回一个未初始化完成的对象（即已经应用了，但是没有具体数据）

volatile并不能保证原子性

例子：

public class Test {
    
    
 
    private static CountDownLatch countDownLatch = new CountDownLatch(1000);
    private volatile static int   num            = 0;
 
    public static void main(String[] args) {
    
    
        ExecutorService executor = Executors.newCachedThreadPool();
        for (int i = 0; i < 1000; i++) {
    
    
            executor.execute(() -> {
    
    
                try {
    
    
                    num++;
                } catch (Exception e) {
    
    
                    e.printStackTrace();
                } finally {
    
    
                    countDownLatch.countDown();
                }
            });
        }
        try {
    
    
            countDownLatch.await();
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }
        executor.shutdown();
        System.out.println(num);
    }
}

结果小于1000，因为++不是原子操作

解决办法：可将int num 改为原子类AtomicInteger num ，调用num.getAndIncrement();方法

volatile原理分析：

猜你喜欢