单例设计模式(创建型设计模式)

一、什么是单例模式

• 单例模式就是单例对象的类只能允许一个实例存在
• 通过单例模式可以保证系统中，应⽤该模式的类只有⼀ 个对象实例

 二、使⽤场景

• 业务系统全局只需要⼀个对象实例，⽐如发号器、 redis连接对象等
• Spring IOC容器中的bean默认就是单例
• spring boot 中的controller、service、dao层中通过 @autowire的依赖注⼊对象默认都是单例的
• 需要频繁实例化然后销毁的对象
• 创建对象时耗时过多或者耗资源过多，但又经常用到的对象

三、单例模式的实现 

 饿汉式单例（程序加载时就创建）

/**
 * 饿汉单例模式
 * 直接new对象，私有构造函数，对外暴露获取方法放回对象实例
 */
public class SingletonHunger {
    private static SingletonHunger singletonHunger = new SingletonHunger();
    private SingletonHunger(){}
    public static SingletonHunger getInstance(){
        return singletonHunger;
    }

}

懒汉式单例（程序加载时不创建，需要时才进行创建） 

/**
 * 懒汉式单例模式
 * 私有化构造函数，声明对象，对外暴露获取实例方法，在方法中创建对象
 */
public class SingletonLazy {


//    private static SingletonLazy instance;

    /**
     * 构造函数私有化
     */
    private SingletonLazy(){
        System.out.println("实例被创建");
    }


    /**
     * 单例对象的方法
     */
    public void process(){
        System.out.println("方法调用成功");
    }

    /**
     * 第一种方式
     * 对外暴露一个方法获取类的对象
     *
     * 线程不安全，多线程下存在安全问题
     *
     */
//    public static SingletonLazy getInstance(){
//        if(instance == null){
//            instance = new SingletonLazy();
//        }
//        return instance;
//    }


    /**
     * 第二种实现方式
     *  通过加锁 synchronized 保证单例
     *
     * 采用synchronized 对方法加锁有很大的性能开销
     *
     * 解决办法：锁粒度不要这么大
     *
     * @return
     */
//    public static synchronized SingletonLazy getInstance(){
//        if(instance == null){
//            instance = new SingletonLazy();
//        }
//        return instance;
//    }


    /**
     * 第三种实现方式
     *
     * DCL 双重检查锁定 （Double-Checked-Locking）,在多线程情况下保持高性能
     *
     * 这是否安全，instance = new SingletonLazy(); 并不是原子性操作
     * 1、分配空间给对象
     * 2、在空间内创建对象
     * 3、将对象赋值给引用instance
     *
     * 假如线程 1-》3-》2顺序，会把值写会主内存，其他线程就会读取到instance最新的值，但是这个是不完全的对象
     * (指令重排)
     * @return
     */
//    public static  SingletonLazy getInstance(){
//        if(instance == null){
//            // A、B
//            synchronized (SingletonLazy.class){
//                if(instance == null) {
//                    instance = new SingletonLazy();
//                }
//            }
//        }
//        return instance;
//    }


    /**
     * volatile是Java提供的关键字，它具有可见性和有序性，
     *
     * 指令重排序是JVM对语句执行的优化，只要语句间没有依赖，那JVM就有权对语句进行优化
     *
     * 禁止了指令重排
     */
    private static volatile SingletonLazy instance;
    public static  SingletonLazy getInstance() {
        //第一重检查
        if (instance == null) {
            // A、B ，锁定
            synchronized (SingletonLazy.class) {
                //第二重检查
                if (instance == null) {
                    instance = new SingletonLazy();
                }
            }
        }
        return instance;
    }
}

public class Main {

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

四、区别跟优缺点

•  饿汉：直接创建对象
  • 优点：实现简单没有多线程同步问题
  • 缺点：不管用不用，对象始终占内存
• 懒汉：按需创建对象 
  • 优点：资源利用率高
  • 缺点：第一次加载时不够快，多线程使用不必要的同步开销大

五、单例模式中饿汉跟懒汉的选择

• 如果对象不⼤，且创建不复杂，直接⽤饿汉的⽅式即可
• 其他情况则采⽤懒汉实现⽅式

注释：仅代表自己学习观点以作笔记，如有瑕疵望谅解