单例模式Singleton（本质：控制实例数目）

爱编程的小庄

于 2022-03-06 17:30:38 发布

阅读量481

点赞数 1

分类专栏：设计模式文章标签：单例模式 java

本文链接：https://blog.csdn.net/weixin_43724911/article/details/123313233

版权

设计模式专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1、前言

有一个场景，我们需要从配置文件中读取属性值注入到java类中，那这个类是不是应该在整个系统中只new一次呢！

思考下有什么设计模式能够实现！！

单例模式是什么

单例模式：认为其本质是控制实例数目。
官话：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

来一个单例模式的接口图：

Singleton：负责创建Singleton类自己的唯一实例，并提供一个getInstance的方法，让外部来访问这个类的唯一实例。

3、如何实现

我们有学过的都清楚实现单例模式有两种方法：懒汉式和饿汉式。

实现：私有化构造方法，提供获取实例的方法，把获取实例的方法变成静态static，直接用类来调用这个方法。

定义存储实例的属性。把这个属性也定义成静态的。

/**
懒汉式单例实现的示例
*/
public class Singleton{
    /**
    定义一个变量来存储创建好的类实例。
    */
    private static Singleton unqueInstance = null;
    /**
    私有化构造方法
    */
    private Singleton(){
        
    }
    /**
    定义一个方法来为客户端提供类实例
    */
    public static synchronized Singleton getInstance(){
        if(unqueInstance == null){
            unqueInstance = new Singleton();
        }
        return unqueInstance;
    }
}

/**
饿汉式
直接创建
*/
public class Singleton{
    /**
    定义一个变量来存储创建好的类实例。
    */
   private static Singleton unqueInstance = new Singleton();
    /**
    私有化构造方法
    */
    private Singleton(){
        
    }
    /**
    定义一个方法来为客户端提供类实例
    */
    public static Singleton getInstance(){
        return unqueInstance;
    }
}

懒汉式：以时间换空间，延迟加载、缓存的思想。
饿汉式：空间换时间。

我们一般都提议延迟加载，提高系统初始化的性能。
眼尖的人发现懒汉式加了一个synchronized 关键字，这说明懒汉式不是线程安全的。
为什么：
在这里插入图片描述
两个请求同时来时，可能会创建两个。
所以人们提出来第一种方法，添加synchronized 同步，但这大大的影响了性能。多个请求同时来时，需要等待。
这时提出了第二种方法：双重检查加锁，并不是每次进入getInstance方法都需要同步，而是先不同步，进入方法后，先检查实例是否存在，如果不存在才进入下面的同步块，这个是第一重检查。进入同步块后，再次检查实例是否存在，如果存在，就在同步的情况下创建一个实例，这是第二重检查，这样一来，就只需要同步一次了。从而减少了多次在同步情况下进行判断所浪费的时间。

public class Singleton{
    /**
    对保存实例的变量添加volatile的修饰。
    */
    private volatile static Singleton instance = null;
    privat Singleton(){
        
    }
    public static Singleton getInstance(){
        //先检查实例是否存在，如果不存在才进入下面的同步块
        if (instance == null) {
            //同步块，线程安全地创建实例。
            synchronized(Singleton.class){
                //再次检查实例是否存在，如果不存在才真正的创建实例。
                if (instance == null) {
                    instance = new Singleton();	
                }
            }
        }
        return instance;
    }
}

这里用到了一个关键字volatile：修饰的变量，不会被本地线程缓存，所有对该变量的读写都是直接操作共享内存。从而确保多个线程能正确的处理该变量。（只能在jdk1.5以上来实现双重检查加锁）,该关键字可能会屏蔽虚拟机中一些必要的代码优化，一般不建议大量采用。

更好的方法：

public class Singleton{
    /**
    类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例
    没有绑定关系，而且只有被调用到时才会装载，从而实现了延迟加载
    */
    public static class SingletonHolder{
        /**
        静态初始化器，由jvm来保证线程安全
        */
        private static Singleton instance = new Singleton();
    }
    
    private Singleton(){}
    
    public static Singleton getIntence(){
        return SingletonHolder.instance;
    }
}