1.解决内存可见性问题

代码在写入 volatile 修饰的变量时：

改变线程⼯作内存中volatile变量副本的值。
将改变后的副本的值从⼯作内存刷新到主内存。

代码在读取 volatile 修饰的变量时：

从主内存中读取volatile变量的最新值到线程的⼯作内存中。
从⼯作内存中读取volatile变量的副本。

给全局变量加上volatile关键字：

import java.time.LocalDateTime;

/**
 * 解决内存可见性问题
 */
public class ThreadDemo18 {
    //全局变量（类级别）
    private static volatile boolean flag = true;

    public static void main(String[] args) {
        //创建子线程1
        Thread t1 = new Thread(() -> {
            System.out.println("线程 1：开始执行！" + LocalDateTime.now());
           while(flag) {
           }
            System.out.println("线程 1：结束执行！" + LocalDateTime.now());
        });
        t1.start();

        //创建子线程2
        Thread t2 = new Thread(() -> {
            //休眠1s
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程 2：修改 flag = false！" + LocalDateTime.now());
            flag = false;
        });
        t2.start();
    }
}

2.解决指令重排序问题

volatile关键字就像一个警告/声明：不允许编译器进行指令优化，JVM就会听程序员的话，不会进行指令优化了。

3.volatile缺点

直接访问⼯作内存(实际是 CPU 的寄存器或者 CPU 的缓存)，速度⾮常快，但是可能出现数据不⼀致的情况。加上volatile，强制读写内存，速度是慢了，但是数据变的更准确了。
它解决不了原子性问题↓ =》使用volatile并不能完全解决线程安全问题，所以volatile也叫轻量级的“锁”。

public class ThreadDemoVolatile {
    static class Counter{
        //变量
        private volatile int number = 0;

        //循环次数
        private int MAX_COUNT = 0;
        public Counter(int MAX_COUNT) {
            this.MAX_COUNT = MAX_COUNT;
        }

        //++方法
        public void incr() {
            for (int i = 0; i < MAX_COUNT; i++) {
                number++;
            }
        }

        //--方法
        public void decr() {
            for (int i = 0; i < MAX_COUNT; i++) {
                number--;
            }
        }

        public int getNumber() {
            return number;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter(100000);
        Thread t1 = new Thread(() -> {
            counter.incr();
        });
        t1.start();

        Thread t2 = new Thread(() -> {
            counter.decr();
        });
        t2.start();

        t1.join();
        t2.join();
        System.out.println("最终的结果：" + counter.getNumber());
    }
}