​​​​​​​

不能放在方法里面（因为每个线程调用都会在方法里面实例化一个locker对象，但不属于同一个对象），然后要用static修饰成静态变量才会起到效果

//单例设计模式
//饿汉模式：在加载类的时候就已经开始创建
//static成员初始化在类加载的时候
//jvm一旦启动就加载
//每个类的类对象在Jvm中只有一份
class Singleton{
    private static Singleton instance =new Singleton();

    private Singleton(){//防止创建多个实例//private,default,public,关键字的访问权限、
    }
    public static Singleton getInstance() {
        return instance;
    }
}
//懒汉模式：在使用的时候再去创建，而不是像懒汉模式一样在类加载(即程序启动)的时候扎堆创建(会使程序启动时间拖慢)。具有分时性，使用户几乎感受不到影响
//懒汉模式的缺点：？
class SingleLazy{
    private static volatile SingleLazy instance=null;
    private static Object locker =new Object();//
    private SingleLazy(){
    }
    //静态方法的特性?
    public static SingleLazy getInstance() {
        // Object locker =new Object();
        //不能放在方法里面（因为每个线程调用都会在方法里面实例化一个locker对象，但不属于同一个对象），
        // 然后要用static修饰成静态变量才会起到效果
        if(instance==null){
            synchronized (locker){
                if(instance==null){
                    instance=new SingleLazy();
                }

            }
        }
        return instance;
    }
}
//new SingleLazy 可看做为赋值操作-->
//1.向内存申请一片空间 2.初始化对象 3.将地址赋给对象--2,3操作可能会被编译器优化成3,2
//然后由于第一个if，其他线程被调度在第一个if条件判断后，会导致直接返回一个未被初始化的对象
//static静态方法类属性如何被开始加载
//注意懒汉模式在多线程的情况下会出现线程安全问题，可能会出现覆盖问题
//为了解决上述问题：1.加锁打包成原子操作
//2.由于上锁会使效率降低，所以可以在外面加if条件判断
//3.为了解决潜在的内存可见性问题和指令重排序问题可在变量上加上一个关键字volatile(表示该变量是可变的，编译器便不会对该变量进行优化操作)
public class Demo2 {
    public static void main(String[] args) {
        Singleton instance=Singleton.getInstance();
       // Singleton singleton=new Singleton();无法创建
        SingleLazy singleLazy=SingleLazy.getInstance();
    }
}