设计模式——单例模式

单例：包含一个自己的类实例属性，并使用private将构造方法私有化，对外只提供getInstance()方法获取该单例对象

懒汉式 即在初始阶段就主动进行实例化

// 创建太阳类 
public class Sun {
    
    private static final Sun sun = new Sun(); // 自行创建的实例 
    // private 保证了实例的私有性，不可见和不可访问性
    // static确保该实例是在类加载时就初始化了 与类同在
    // final表示不可修改

    private  Sun(){ // 构造方法私有化 就可以避免任何人都能创建Sun实例

    }

    // 使得外部能够访问到它 使用static修饰 直接通过类来调用
    public  static  Sun getInstance(){
        return sun;
    }
}

懒汉式 只有在需要的时候才被实例化

public class Sun {
    // 懒汉式
    private static Sun sun;// 这里不进行实例化
    
    private Sun(){
        //  构造方法私有化        
    }
  
    public static Sun getInstance(){
        if(sun == null){
            sun = new Sun(); // 在外部访问的时候 如果为空再实例化
        }

        return sun;
    }
    
}

这样做的好处：没有请求就不需实例化，节省了内存空间
坏处：

• 第一次请求时候比较慢
• 在多线程场景下，并发请求在判空逻辑处，可能会出现多次实例化的情况，违背了单例的理念

修改，添加同步锁synchronized

public  static synchronized Sun getInstance(){ // 加入同步锁
        if(sun == null){
            sun = new Sun();
        }

        return sun;
    }

上述写法虽然控制了线程的执行顺序，但是会造成线程阻塞（锁粒度过大），资源浪费

再次修改 减小锁粒度，并且添加volatile关键字保证同步

public class Sun {
    // 懒汉式-双重锁
    // 添加volatile关键字 保证变量的同步性，一致性
    private volatile static Sun sun;// 这里不进行实例化

    private Sun(){
        //  构造方法私有化
    }

    public  static  Sun getInstance(){ // 加入同步锁
        // 第一次判空 保证线程并发的高效
        if(sun == null){
            // 修改同步锁粒度
            synchronized (Sun.class){
                // 两次判空 保证实例化单次运行
                if(sun == null){
                    sun = new Sun();
                }
            }
        }
        return sun;
    }

}

总结
通常情况下偏向使用饿汉模式，因为单例迟早是要被实例化占用内存的，延迟加载意义不大，并且加锁解锁反而会造成资源浪费，同步操作会降低CPU的利用率，使用不当还会带来不必要的风险