面试必问的设计模式 | 单例模式

一、简介

单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的一个类只有一个实例。即一个类只有一个对象实例。

单例模式的要点有三个；一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。

从具体实现角度来说，就是以下三点：一是单例模式的类只提供私有的构造函数，二是类定义中含有一个该类的静态私有对象，三是该类提供了一个静态的公有的函数用于创建或获取它本身的静态私有对象。

优点：
一、实例控制
单例模式会阻止其他对象实例化其自己的单例对象的副本，从而确保所有对象都访问唯一实例。

二、灵活性
因为类控制了实例化过程，所以类可以灵活更改实例化过程。

缺点：
一、开销
虽然数量很少，但如果每次对象请求引用时都要检查是否存在类的实例，将仍然需要一些开销。可以通过使用静态初始化解决此问题。

二、可能的开发混淆
使用单例对象（尤其在类库中定义的对象）时，开发人员必须记住自己不能使用new关键字实例化对象。因为可能无法访问库源代码，因此应用程序开发人员可能会意外发现自己无法直接实例化此类。

三、对象生存期
不能解决删除单个对象的问题。在提供内存管理的语言中（例如基于.NET Framework的语言），只有单例类能够导致实例被取消分配，因为它包含对该实例的私有引用。在某些语言中（如 C++），其他类可以删除对象实例，但这样会导致单例类中出现悬浮引用。

场景：
一、频繁创建和销毁对象。
二、创建对象消耗过多的资源。
三、工具类对象。
四、频繁访问数据库或文件的对象。

二.单例模式的几种写法

1) 「饿汉模式」【静态常量】【可用】

//饿汉模式-静态常量
//通用单例模式:饿汉模式
//解决线程时间差造成的对象多余和混乱
public class HungryPatternStaticConstant {

    //加载时被初始化，直接生成对象，需要时直接获取
    private static final HungryPatternStaticConstant instance = new HungryPatternStaticConstant();

    //不能直接生成实例
    private HungryPatternStaticConstant() {
    }

    public synchronized static HungryPatternStaticConstant getInstance() {
        return instance;
    }
}

2) 「饿汉模式」【静态代码块】【可用】

//饿汉模式-静态代码块
public class HungryPatternStaticCodeBlock {
    private static HungryPatternStaticCodeBlock instance;

    static {
        instance = new HungryPatternStaticCodeBlock();
    }

    private HungryPatternStaticCodeBlock(){}

    public static HungryPatternStaticCodeBlock getInstance(){
        return instance;
    }
}

饿汉模式：

优点：类装载时完成实例化，避免线程同步没有检测到已创建的实例，从而创建出来多余的实例违反单例模式实例唯一原则的问题。

缺点：若自始至终都没有使用过这个类，则会造成内存浪费问题。

3) 「懒汉模式」【线程不安全】【不可用】

//懒汉模式-线程不安全
public class IdlerPatternUnThreadSafe {

    private static IdlerPatternUnThreadSafe instance = null;

    //不能直接生成实例
    private IdlerPatternUnThreadSafe() {
    }

    public static IdlerPatternUnThreadSafe getInstance() {
       if(instance == null){
           instance = new IdlerPatternUnThreadSafe();
        }
        return instance;
    }
}

只能在单线程下使用，多线程情况下，由于判断为 null 的时间差问题，会导致造成多个实例。

4) 「懒汉模式」【线程安全,同步方法】【不推荐】

//懒汉模式-线程安全-线程同步
public class IdlerPatternThreadSafeSynchronizedMethod {

    private static IdlerPatternThreadSafeSynchronizedMethod instance;

    private IdlerPatternThreadSafeSynchronizedMethod(){}

    public static synchronized IdlerPatternThreadSafeSynchronizedMethod getInstance(){
        if(instance == null){
            instance = new IdlerPatternThreadSafeSynchronizedMethod();
        }
        return instance;
    }
}

解决了线程不安全问题，效率低，每次获取实例都需要进行线程同步。

5) 「懒汉模式」【线程安全，同步代码块】【不可用】

//懒汉模式-线程安全-同步的代码块
public class IdlerPatternThreadSafeSynchronizedCode {

    private static IdlerPatternThreadSafeSynchronizedCode instance;

    private IdlerPatternThreadSafeSynchronizedCode(){}

    public static IdlerPatternThreadSafeSynchronizedCode getInstance(){

        if(instance == null){
            synchronized (IdlerPatternThreadSafeSynchronizedCode.class){
                instance = new IdlerPatternThreadSafeSynchronizedCode();
            }
        }
        return instance;
    }
}

解决了效率低的问题，多线程情况下，由于判断为 null 的时间差问题，会导致造成多个实例。

6) 「单例模式-双重检查」【推荐】

//单例模式-双重检查
public class SingletonDuplicationCheck {

    private static volatile SingletonDuplicationCheck instance;

    private SingletonDuplicationCheck(){}

    public static SingletonDuplicationCheck getInstance(){
        if(instance == null){
            synchronized (SingletonDuplicationCheck.class){
                if(instance == null){
                    instance = new SingletonDuplicationCheck();
                }
            }
        }
        return instance;
    }
}

双重 if(instance == null) 保证线程安全，效率高，第二次执行直接 return 对象。

7) 「单例模式-静态内部类」【推荐】

//单例模式-静态内部类
public class SingletonStaticInsideClass {
    
    private SingletonStaticInsideClass(){}
    
    private static class SingletonInstance{
        private static final SingletonStaticInsideClass INSTANCE = new SingletonStaticInsideClass();
    }
    
    public static SingletonStaticInsideClass getInstance(){
        return SingletonInstance.INSTANCE;
    }
}

与饿汉模式的区别：
SingletonStaticInsideClass 被加载时不会直接被实例化，调用 getInstance()，装载 class SingletonInstance 类，完成 SingletonStaticInsideClass 实例化。

类的静态属性只会在第一次类加载时初始化，JVM 保证了线程安全，类初始化时，别的线程无法进入。

延迟加载，效率高，避免线程不安全。

ABOUT

公众号：【星尘Pro】
github：https://github.com/huangliangyun

推荐阅读
史上最全，最完美的 JAVA 技术体系思维导图总结，没有之一!
全站导航 | 文章汇总!