Volatile关键字

1.保证线程可见性
    不可见：两个线程 当一个线程操作这个值，其他线程不知道，用的还是原来的值
    底层用了 cpu的缓存一致性协议
2.禁止指令重排序
    不是禁止cpu的指令排序

单例：就是保证在JVM内存里，永远只有某一个类的一个实例
双重检查  , 加Volatile重点，不加Volatile 问题就会出现在指令重排序上，一般并发超高的时候才会出现
锁细化：加锁给少量代码，不用锁住一个方法

如果两个线程同时都判断 instance 为null了 ，一个线程加锁完释放掉后，另一个线程又会重新初始化一次变量了
所以要用双重检查单例：
public class Mgr01(){
    private static volatile Mgr01 INSTANCE;

    privateMgr01(){

    }
    
    public static Mgr01 getInstance(){
        //双重检查
        if(INSTANCE == null){
            synchronized(Mgr01.class){
                if(INSTANCE == null){
                    try{
                        Thread.sleep(1);
                    }catch(Exception e){
                        e.printStackTrace();
                    }
                    INSTANCE = new Mgr01();    
                }
            }
        }
        return INSTANCE;
    }

    public static void main(String []args){
        for(int i = 0;i<100;i++){
            new Thread(()->{
                System.out.println(Mgr01.getInstance().hashCode());        
            }).start();
        }
    }
}

INSTANCE = new Mgr01();  :  new一个对象，根据编译器编译完，这句指令其实是分为三步：
第一步 是给这个对象申请内存  默认值 int类型 是0
第二步 是初始化成员变量
第三步 把内存这块的内容赋值给INSTANCE    instance是在栈内存里

Volatile不保证原子性：
Volatile 并不能保证多个线程共同修改running 变量时所带来的不一致问题  也就是说Volatile不能替代synchronized
count 保证可见性的操作，但是count++ ，它本身并不是一个原子性的操作 

new Thread（t::m,"t1"）.start();
t::m   ： lambda表达式  new Thread（new Runnable（run（）{m（）}).start();
有一个方法名叫m