volatile的理解

1.1 volatile是Java虚拟机提供的轻量级同步机制，三大特性：

• 保证可见性 : 一个线程修改了主内存的值，其他线程能够看到知道，第一时间的通知机制就是可见性
• 不保证原子性

• 禁止指令重排

  1.2 JMM理解

• jvm：java虚拟机

• JMM：java内存模型，本身是一种抽象概念，并不真实存在，描述一种规则或者规范，通过这种规则定义了程序中的各个变量（包括实例字段、静态字段和构成数组对象的元素）的访问方式。

JMM关于同步的定义

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

速率： 硬盘 < 内存 < 缓存cache < cpu

JMM的三大特性

可见性

package com.interview.demo;
import java.util.concurrent.TimeUnit;
/**
* @Author leijs
* @date 2022/3/28
*/
public class VolatileDemo {
    /**
    * 验证可见性
    *
    * @param args
    */
    public static void main(String[] args) {
        MyData myData = new MyData();
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + " come in.");
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            myData.addToo60();
            System.out.println(Thread.currentThread().getName() + "update " + myData.num);
        }).start();
        while (myData.num == 0) {
        }
        System.out.println(Thread.currentThread().getName() + " over!");
    }
}
class MyData {
    volatile int num = 0;
    public void addToo60() {
        this.num = 60;
    }
}

各个线程对主内存中的共享变量的操作都是各个线程各自拷贝到自己的工作内存进行操作再回写到主内存中的。这就可能存在一个线程AAA修改了共享变量X的值但是还未写回主内存，另一个线程BBB又对主内存中的同一个共享变量X进行操作，但此时A线程工作内存中的共享变量X对B不可见，这种工作内存和主内存同步延迟现象就造成了可见性问题。

原子性

原子性是什么意思？不可分割、完整性，也即某个线程正在做某个具体业务时，中间不可被加塞或者被分割，需要整体完整，要么同时成功，要么同时失败。

package com.interview.demo;
import java.util.concurrent.TimeUnit;
/**
 * @Author leijs
 * @date 2022/3/28
 */
public class VolatileDemo {
    public static void main(String[] args) throws InterruptedException {
//        seeOkByVolatile();
        MyData myData = new MyData();
        for (int i = 0; i < 20; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    myData.addPlus();
                }
            }, String.valueOf(i)).start();
        }
        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName() + ":" + myData.num);
    }
    /**
     * 验证可见性
     */
    private static void seeOkByVolatile() {
        MyData myData = new MyData();
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + " come in.");
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            myData.addToo60();
            System.out.println(Thread.currentThread().getName() + "update " + myData.num);
        }).start();
        while (myData.num == 0) {
        }
        System.out.println(Thread.currentThread().getName() + " over!");
    }
}
class MyData {
    volatile int num = 0;
    public void addToo60() {
        this.num = 60;
    }
    public void addPlus() {
        num++;
    }
}

原因

num++:

• 执行getField拿到初始值
• 执行ipad进行+1操作
• 执行putfield写把累加值写回主内存

如何解决

• synchronized

• AtomicInteger

    AtomicInteger automiInteger = new AtomicInteger();
    public void addAtomic() {
        automiInteger.incrementAndGet();
    }

  有序性

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

  源代码 -> 编译器优化的重排 -> 指令并行的重排 -> 内存系统的重排 -> 最终执行的指令

处理器在进行重排序时必须考虑指令之间的数据依赖性。多线程环境线程交替执行，由于编译器优化重排的存在，多线程使用的变量能否保证一致性是无法确定的，结果无法预测。

package com.interview.demo;
/**
 * @Author leijs
 * @date 2022/3/28
 */
public class ReSortSeqDemo {
    int a = 0;
    boolean flag = false;
    public void method01() {
        // 这两个数据不存在依赖性，先后顺序多线程执行不确定
        a = 1;
        flag = true;
    }
    /**
     * 可能存在指令重排
     */
    public void method02() {
        if (flag) {
            a = a + 5;
            System.out.println("value: " + a);
        }
    }
}

volatile禁止指令重排

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

内存屏障（memory barrier）

又称内存栅栏，是一个CPU指令，作用有两个：

• 保证特定操作的执行顺序
• 保证某些变量的内存可见性（利用该特性实现volatile的内存可见性）

由于编译器和处理器都能执行指令重排优化，也就是说通过插入内存屏障禁止内存屏障前后的指令进行重排序优化。内存屏障的另一作用是强制刷出各种CPU的缓存数据，因此任何CPU上的线程都能读取到这些数据的最新版本。

volatitle变量写操作时

写操作后加上一条store屏障指令，将工作内存中的共享变量刷新到主内存。

volatitle变量读操作时

写操作后加上一条load屏障指令，从主内存中读取共享变量

1.3 哪些地方使用过volatile？

单例模式DCL

double check lock双端检索机制。不一定线程安全，因为有指令重排序的存在，加入volatile可以禁止指令重排。
原因：某一个线程在执行到第一次检测，读取到instance不为null时，instance的引用对象可能没有完成初始化。
instance = new SingletonDemo() 可以分为3步完成：

1. memory = allocate // 分配对象内存空间
2. instance(memory) // 初始化对象
3. instance = memory // 设置instance指向刚分配的内存地址，此时instance != null

步骤2和步骤3不存在数据依赖关系，重排前后在单线程中并没有改变，因此这种重排优化是允许的。
当一条线程访问instance != null的时候，由于instance实例未必初始化完成，也就造成了线程安全问题。

package com.interview.demo;
/**
 * @Author leijs
 * @date 2022/3/28
 */
public class SingletonDemo {
    private static volatile SingletonDemo instance = null;
    private SingletonDemo() {
        System.out.println(Thread.currentThread().getName() + "我是构造方法");
    }
    public static SingletonDemo getInstance() {
        if (instance == null) {
            synchronized (SingletonDemo.class) {
                if (instance == null) {
                    instance = new SingletonDemo();
                }
            }
        }
        return instance;
    }
    public static void main(String[] args) {
//        System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());
//        System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());
//        System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());
//
//        System.out.println();
        // 并发多线程，构造方法
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                SingletonDemo.getInstance();
            }, String.valueOf(i)).start();
        }
    }
}