笔记A《volatile 的理解》

本篇来自于尚学堂《2019互联网面试题第2季》的视频内容进行整理汇总。

volatile 关键字

volatile 是 Java 虚拟机提供的轻量级的同步机制，其主要作用：

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

保证可见性

线程在自己的工作内存拷贝主内存中的共享数据，线程更新共享数据后再刷回到主内存中。其他线程会感知共享数据的变化，拷贝最新的数据到自己的工作内存进行操作。

public class VolatileDemo {
    public static void main(String[] args) {
        MyData data = new MyData();
        for(int i = 0;i<20;i++){
            new Thread(()->{
                try {
                    TimeUnit.SECONDS.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                data.addTen();
                System.out.println(Thread.currentThread().getName()+" 的 number 变量变化了: "+ data.number);
            },"线程1 "+String.valueOf(i)).start();

        }

        while (data.number == 0){
        }
        System.out.println(Thread.currentThread().getName()+" 的 number 变量变化了: " + data.number);
    }
}

class MyData{
    volatile int number = 0;
    public void addTen(){
        this.number = 10;
    }
}

不保证原子性

所谓原子性，就是在进行一个操作时，这个操作要么完成，要么失败。类似于 SQL 的事务。

如案例所示，使用 i++ 来模拟原子性。

public class VolatileDemo {

    public static void main(String[] args) {
        MyData data = new MyData();
        for(int i = 0;i<20;i++){
            new Thread(()->{
                for(int j = 0;j < 1000;j++) {
                    data.addPlus();
                }
//                System.out.println(Thread.currentThread().getName()+" 的 number 变量变化了: "+ data.number);
            },"线程1 "+String.valueOf(i)).start();
        }
        while (Thread.activeCount() > 2){
            Thread.yield();
        }

        System.out.println(Thread.currentThread().getName()+" 的 number 变量变化了: " + data.number);
    }
}

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

如何避免非原子性

1. 可以使用 JUC 的原子类来进行操作；
2. 可以使用同步锁机制。

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

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

        System.out.println(Thread.currentThread().getName()+" 的 number 变量变化了: " + data.atomicInteger);
    }
}

class MyData{
     // JUC 原子类
    AtomicInteger atomicInteger = new AtomicInteger();
    public void addPlus(){
        atomicInteger.getAndIncrement();
    }
    // 同步锁
    volatile int number = 0;
    public synchronized void addPlus(){
        number++;
    }
}

禁止重排

虚拟机在执行程序时，为了提高性能，编译器会对程序指令进行优化重排，继而形成最终的执行指令。由于优化重排会考虑指令间的依赖关系，在单线程环境下，不会出现问题。而在多线程环境下，线程交替运行，程序优化重排后，变量的一致性无法得到保证。

volatile 实现禁止指令重排优化，从而可以避免在多线程环境下程序出现乱序执行的现象。

内存屏障（Memory Barrier，内存栅栏）：是一个 CPU 指令，其作用有：

1. 保证特定操作的执行顺序；
2. 保证某些变量的内存可见性。

由于编译器和处理器都能执行指令重排优化，如果在指令间插入一条 Memory Barrier，则会告诉编译器和处理器，不管什么指令都不能和这条 Memory Barrier 指令重排，也就是说：通过插入内存屏障禁止在内存屏障前后的指令执行重排序。内存屏障另一个作用是强制刷出各种 CPU 的缓存数据，因此任何 CPU 上的线程都能读取到这些数据的最新版本。

• 对 volatile 变量进行写操作时，会在写操作后加入一条 store 屏障指令，将工作内存中的共享变量刷新回主内存；
• 对 volatile 变量进行读操作时，会在读操作前加入一条 load 屏障指令，从主内存中读取共享变量。

JMM

JMM(Java内存模型Java Memory Model, 简称JMM) 本身是一种抽象的概念 ，并不真实存在, 它描述的是一组规则或规范通过规范定制了程序中各个变量(包括实例字段,静态字段和构成数组对象的元素)的访问方式。

JMM关于同步规定:

1. 线程解锁前,必须把共享变量的值刷新回主内存
2. 线程加锁前,必须读取主内存的最新值到自己的工作内存
3. 加锁解锁是同一把锁

由于 JVM 运行程序的实体是线程, 而每个线程创建时JVM 都会为其创建一个工作内存(有些地方成为栈空间), 工作内存是每个线程的私有数据区域, 而 Java 内存模型中规定所有变量都存储在主内存, 主内存是共享内存区域, 所有线程都可访问。但线程对变量的操作 (读取赋值等) 必须在工作内存中进行。

1. 首先要将变量从主内存拷贝到自己的工作空间；
2. 然后对变量进行操作；
3. 操作完成再将变量写回主内存, 不能直接操作主内存中的变量。

各个线程中的工作内存储存着主内存中的变量副本拷贝,因此不同的线程无法访问对方的工作内存,线程间的通讯(传值) 必须通过主内存来完成,其简要访问过程如下图:

单例模式 DCL

class Singleton{
    private static volatile Singleton singleton = null;

    private Singleton(){
    }

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