单例模式学习总结以及五种实现方式

用最简单的语言阐述最深刻的知识，纯属个人总结，有所借鉴。

设计模式概念

设计模式是一套被多人知晓并且被反复使用、经过分类的、代码设计经验的总结。目的是提高代码重用性，提高开发效率，保证代码可靠性。

设计模式分类

设计模式分为三大类：创建型模式、结构型模式、行为型模式。

创建型:对象实例化的模式，解耦了对象的实例化过程

结构型:类和对象结合在一起

行为性:类和对象如何交互，及划分责任和算法

 

单例模式

单例模式是一种常见创建型模式，可以保证系统中一个类只有一个实例而且该实例易于外界访问。

单例模式原则

私有的构造器、私有静态变量、公有静态方法

单例模式五种实现

饿汉模式、懒汉模式、双检锁懒汉模式、静态内部类模式、枚举模式。

 

接下来我们代码实现这五种并且进行分析：

饿汉模式

/**
 * 饿汉模式
 */
public class SingletonTest1 {

    //私有构造器
    private SingletonTest1() {
    }

    //私有静态变量
    private static final SingletonTest1 singletonTest1 = new SingletonTest1();

    //公有静态方法
    public static SingletonTest1 getInstance() {
        return singletonTest1;
    }

}

分析：饿汉模式记载类时不管有没有调用getInstance()方法，都会预先在系统中创建一个静态对象，在多线程的情况下是安全的

优点：线程安全，调用效率高

缺点：资源浪费，占用内存，不能延迟加载

懒汉模式

/**
 * 懒汉模式
 */
public class SingletonTest2 {
    //私有构造
    private SingletonTest2() {
    }

    //私有静态变量
    private static volatile SingletonTest2 singletonTest2 = null;

    //公有静态方法
    public static SingletonTest2 getInstance() {
        if (singletonTest2 == null) {
            singletonTest2 = new SingletonTest2();
        }
        return singletonTest2;
    }

    //单锁懒汉模式
    public static synchronized SingletonTest2 getInstanceSync() {
        if (singletonTest2 == null) {
            singletonTest2 = new SingletonTest2();
        }
        return singletonTest2;
    }

    //双检锁懒汉模式
    public static SingletonTest2 getInstanceDcl() {
        if (singletonTest2 == null) {
            synchronized (SingletonTest2.class){
                if (singletonTest2 == null){
                    singletonTest2 = new SingletonTest2();
                }
            }
        }
        return singletonTest2;
    }

}

分析：懒汉模式不会预先创建对象，只有第一次调用getInstance()方法时才会创建对象，但是只有添加synchronized关键字才能保证多线程下的安全性

优点：线程安全，可以延迟加载

缺点：必须加锁，不加锁会有并发问题，调用效率低

双检锁DCL(Double Check Lock)模式：第一次判断 singletonTest2 == null为了避免非必要加锁，当第一次加载时才对实例进行加锁再实例化。这样既可以节约内存空间，又可以保证线程安全。

JDK1.6之前，由于jvm存在乱序执行功能，导致DCL也会出现线程不安全的情况。具体详情参考

https://blog.csdn.net/wuzhiwei549/article/details/80006533

JDK1.6及以后，只要定义private static volatile SingletonTest2 singletonTest2 = null;就可解决DCL失效问题。

volatile确保singletonTest2 每次均在主内存中读取

静态内部类模式

/**
 * 内部静态类
 */
public class SingletonTest3 {
    //私有构造
    private SingletonTest3() {
    }

    //内部静态类
    private static class Singleton {
        private static final SingletonTest3 singletonTest3 = new SingletonTest3();
    }

    //公有方法
    public static SingletonTest3 getInstance() {
        return Singleton.singletonTest3;
    }

}

分析：类加载时并不需要立即加载内部类，内部类不被加载则不去初始化singletonTest3，故而不占内存。即当SingletonTest3 第一次被加载时，并不需要去加载Singleton，只有当getInstance()方法第一次被调用时，才会去初始化singletonTest3，第一次调用getInstance()方法会导致虚拟机加载Singleton 类，能确保线程安全，保证单例唯一性，延迟了单例的实例化。

优点：线程安全，调用效率高，可以延迟加载

枚举类模式

/**
 * 枚举类
 */
public enum  SingletonTest4 {
    SINGLETON_TEST_4;
    public void otherMethod(){
        //TODO
    }
}

分析：枚举在java中和普通类一样，都能拥有字段和方法，而且枚举实例是线程安全的，在任何情况下，它都是一个单例。

直接用SingletonTest4 .SINGLETON_TEST_4的方式进行调用。

优点：线程安全，调用效率高，可以延迟加载，防止反射和反序列化的漏洞

 

附加面试题一道：

你是如何使用单例模式的？

某些java类只是提供一些方法供其他类的方法调用，而它的方法对自身的成员变量基本不改变，那么为了运行资源以及运行效率，它们会在一开始的时候初始化一个示例，如果某个地方想使用这个类提供的方法，就用这个实例去调用
实际场景：spirng 中几乎所有的service层都是单例的，spring 对于每个@Service注解的Class在初始化的时候，就会实例化一个单例，在其他模块中如果要使用直接通过@Autowired或者@Resource注解进来，但是其实他们注入的都是同一个单例，因为这些service他自己本身没有什么会被方法改变的成员变量，多线程调用不会造成需要同时修改某一个变量的情况，所以可以用单例，用单例的好处是，对象的频繁创建与销毁要额外的消耗大部分资源，单例比起在调用时new 一个对象省去了创建对象所消耗的时间，效率更高。

 

个人学习总结，不喜勿喷，如有错误不妥之处，欢迎评论指出，非常感谢。