1、volatile关键字

先看例子：


 class Counter {
    public int flag = 0;
}

public class Test4{
    public static void main(String[] args) {
        Counter counter = new Counter();
        Thread t1 = new Thread(() -> { //创建一个线程，用来读取数据
            while (counter.flag == 0) {
            }
            System.out.println("循环结束!");
        });
        
        Thread t2 = new Thread(() -> {   //建立一个线程用来修改数据
            Scanner scanner = new Scanner(System.in);
            System.out.println("输入一个整数:");
            counter.flag = scanner.nextInt();
        });
        t1.start();
        t2.start();
    }

}

结果：
在这里插入图片描述
我们输入了一个非零的数字，理论上应该直接打印“循环结束”，线程t1就结束了，可是实际上却没有这样，这也是一个典型的线程安全问题！

内存可见性问题：
一个线程对一个变量进行读取操作，另一个线程对变量进行修改，但是此时读取到的值不一定是修改后的值，这个读线程就不能准确的感知变量的变化，所以此时就需要使用volatile这个关键字来避免这种情况
在这里插入图片描述

注意：volatile只能修饰变量
不能修饰构造方法内部的局部变量因为方法里的局部变量只能在当前方法里使用，出了方法变量就没了，方法内部的变量在“栈”空间上，每个线程都有自己的“栈空间”，即使是同一个方法在多个线程中备点用，这里的局部变量也会处在不同的栈空间中，本质上是不同变量。

小知识：
1.CPU读取寄存器的速度比读取内存快了很多，因此CPU内部引入缓存cache，寄存器存储空间小，速度快，但是很贵；中间搞了个cache：存储空间居中，读写速度居中，成本居中。
2.工作内存：CPU寄存器+CPU的cache。当CPU要读取一个内存数据的时候，可能从内存读，也可能从cache读，也可能从寄存器读。
3.有的CPU可能没有cache，有的有一个cache，还可能有多个，现在的CPU普遍是3级cache，L1,L2,L3…

2、volatile和synchronized对比

1、 volatile 和 synchronized 有着本质的区别.，synchronized 能够保证原子性, volatile 保证的是内存可见性
2、 synchronized 既能保证原子性, 也能保证内存可见性.

3、wait和notify方法

因为线程的抢占式执行，导致实际开发中有太多的不可能性，因此java中就有wait和notify这两个方法来控制线程的执行顺序。
例如：t1和t2两个线程，我们希望t1先执行，执行到某个程度让t1wait阻塞，接着让t2执行，等t2执行完之后，再用notify来唤醒t1线程继续执行。
问题：为什么不可以用join或者sleep来控制呢？
使用join就必须等t1全部执行完才能让t2执行，使用sleep，无法估计t1执行到哪个程度来唤醒t2；
但是使用wait和notify就可以完美的解决上述问题。
在这里插入图片描述

在这里插入图片描述

也就是说，如果没有明确说明是哪个对象的，notify就会随机挑一个正在wait的线程进行通知；
看代码：通过代码就可以看出该方法的好处：

public class Test2 {
    public static void main(String[] args) {
            Object locker1 = new Object();//创建对象1
            Object locker2 = new Object();//创建对象2
            Thread t1 = new Thread(() -> {
                synchronized (locker2){   //锁2等待
                    try {
                        locker2.wait();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
                System.out.println("a");

            });
            Thread t2 = new Thread(() -> {
                synchronized (locker1){  //锁1等待
                    try {
                        locker1.wait();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
                System.out.println("b");
                synchronized (locker2){  //锁2解锁
                    locker2.notify();
                }
            });
            Thread t3 = new Thread(() -> {
                System.out.println("c");
                synchronized (locker1){//锁1解锁
                    locker1.notify();
                }
            });

            t1.start();
            t2.start();
            t3.start();
    }
}