单例模式

单例模式：程序运行时，让一个类只能创建一个对象

饿汉式：

• 构造方法私有化
• 创建当前类对象
• 对外提供公共的访问方法将SingletonHungary对象暴露给外部

//单例模式------饿汉式
public class SingletonHungary{
    
    
    //1.将构造方法私有化
    private SingletonHungary(){
    
    
        
    }
    //2.创建当前类的对象
    private static SingletonHungary s = new SingletonHungary();
    //3.对外提供公共访问方法将SingletonHungary对象暴露给外部
    public static SingletonHungary getInstance(){
    
    
        return s;
    }
}

懒汉式

//单例模式----懒汉式，延迟加载模式
public class SingletonLazy {
    
    

    //1.将构造方法私有化
    private SingletonLazy() {
    
    
        System.out.println(Thread.currentThread().getName() + "ok");
    }

    //2.创建当前类的引用
    private static volatile SingletonLazy s;

    //3.对外提供公共的访问方法将SingletonHungary对象暴露给外部
    public static SingletonLazy getInstance() {
    
    
        if (s == null) {
    
    
            synchronized (SingletonLazy.class) {
    
    
                if (s == null) {
    
    
                    s = new SingletonLazy();//不是一个原子性操作
                   /**
                     * 1.分配内存空间
                     * 2.执行构造方法，初始化对象
                     * 3.把这个对象指向这个空间
                     *
                     * 123
                     * 132 A
                     *     B
                     */
                    
                }
            }
        }
        return s;
    }

    //测试多线程
    public static void main(String[] args) {
    
    
        for (int i = 0; i < 100; i++) {
    
    
            new Thread(() -> {
    
    
                SingletonLazy.getInstance();
            }).start();

        }
    }

}

注意：

懒汉式在创建对象的时候不是一个原子性的操作，由于它不是一个原子性的操作，所以它在new 一个对象的时候有三个步骤：

1.分配内存空间内

2.执行构造方法，初始化对象

3.把这个对象指向这个空间

我们期望的是按照123的顺序执行，但在并发情况下，有可能会执行132，这是在电脑的cup上是可以做到的，

A经常进来的时候没有问题（也就是第一次进来的时候），但B进程进来就有问题了，由于它已经指向了这个空间了，B会认为这个对象不是null，就直接返回了，由于B还没完成构造，所以它的这个空间其实是一个虚的，

所以解决这个问题的方法是：必须在对象的引用上加一个volatile关键字，实现变量修改的可见性