设计模式--单例模式-CSDN博客

本文链接：https://blog.csdn.net/w1992wishes/article/details/78423413

对于系统中的某些类来说，只有一个实例很重要，例如，Windows任务管理器。通常情况下，无论我们启动任务管理多少次，Windows系统始终只能弹出一个任务管理器窗口，也就是说在一个Windows系统中，任务管理器存在唯一性。为什么要这样设计呢？

其一，如果能弹出多个窗口，且这些窗口的内容完全一致，全部是重复对象，这势必会浪费系统资源，任务管理器需要获取系统运行时的诸多信息，这些信息的获取需要消耗一定的系统资源，包括CPU资源及内存资源等，浪费是可耻的，而且根本没有必要显示多个内容完全相同的窗口；
其二，如果弹出的多个窗口内容不一致，问题就更加严重了，这意味着在某一瞬间系统资源使用情况和进程、服务等信息存在多个状态，例如任务管理器窗口A显示“CPU使用率”为10%，窗口B显示“CPU使用率”为15%，到底哪个才是真实的呢？这会误导用户。

在实际开发中，也经常有类似的情况，为了节约系统资源，有时需要确保系统中某个类只有唯一一个实例，当这个唯一实例创建成功之后，就无法再创建一个同类型的其他对象，所有的操作都只能基于这个唯一实例。为了确保对象的唯一性，可以通过单例模式来实现。

二、什么是单例模式

单例模式相对简单，它确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。

单例模式的要点有三个：

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

单例模式是一种对象创建型模式。单例模式又名单件模式或单态模式。

三、为什么要用该模式

前言中已经介绍过，在开发软件中，可能有些类的创建十分消耗系统资源，或者初始化时间较长，像线程池，数据库连接池，秉着节约的态度，为了提升软件的性能，一般只允许这些类只被创建出一个实例，且能够全局共享。

四、模式的结构

单例模式的结构简单，只有一个类。

五、代码示例

单例模式结构虽然简单，但代码里面还是有许多道道，有好几种写法，下面具体看看：

5.1、饿汉式

/**
 * Created by w1992wishes on 2017/11/2.
 */
public class Singleton {
    private static Singleton instance = new Singleton();
    private Singleton(){}
    public static Singleton getInstance(){
        return instance;
    }
}

这种方式和名字很贴切，饥不择食，在类装载的时候就创建，不管用不用，先创建了再说。
缺点是：如果一直没有被使用，便浪费了空间，典型的空间换时间，如果初始化很耗费时间，同时也会推迟系统的启动时间。
优点是：每次调用的时候，就不需要再判断，节省了运行时间。

java Runtime使用的就是“饿汉式”单例：

5.2、懒汉式（非线程安全）

/**
 * Created by w1992wishes on 2017/11/2.
 */
public class Singleton {
    private static Singleton instance;
    private Singleton(){}
    public static Singleton getInstance(){
        if (instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}

懒汉模式申明了一个静态对象，在用户第一次调用时初始化。
缺点是：第一次加载时需要实例化，反映稍慢一些，而且在多线程不能正常工作，很可能会造成多次实例化，就不再是单例了。
优点是：使用时才创建，节约了资源。

“懒汉式”与“饿汉式”的最大区别就是将单例的初始化操作，延迟到需要的时候才进行，这样做在某些场合中有很大用处。比如某个单例用的次数不是很多，但是这个单例提供的功能又非常复杂，而且加载和初始化要消耗大量的资源，这个时候使用“懒汉式”就是非常不错的选择。

5.3、懒汉式（线程安全）

/**
 * Created by w1992wishes on 2017/11/2.
 */
public class Singleton {
    private static Singleton instance;
    private Singleton(){}
    public static synchronized Singleton getInstance(){
        if (instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}

在“懒汉式（非线程安全）”的基础上加上一个synchronized修饰，就是线程安全的了。
缺点是：其实只有第一次调用getInstance时才真正需要同步，一旦设置好instance实例后，之后每次同步都是累赘，平白增添性能消耗。
优点是：可以在多线程环境下确保只初始化一个单例。

5.4、双重校验锁（DCL）

/**
 * 注意此处使用的关键字 volatile，它保证了可见性
 * 被volatile修饰的变量的值，将不会被本地线程缓存，
 * 所有对该变量的读写都是直接操作共享内存，从而确保多个线程能正确的处理该变量。
 * Created by w1992wishes on 2017/11/2.
 */
public class Singleton {
    private static volatile Singleton instance;
    private Singleton(){}
    public static Singleton getInstance(){
        if (instance == null){
            synchronized (Singleton.class){
                if (instance == null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

如果程序可以接受synchronized带来的性能负担，“懒汉式（线程安全）”可以使用，但如果很关心性能，“双重校验锁（DCL）”将会带来很大帮助。
在getInstance()方法中对instance进行了两次判空，第一次是为了不必要的同步，因为只有第一次调用getInstance()方法才需要同步，第二次是在singleton等于null的情况下才创建实例。

缺点是：代码相对其他较为复杂，有一定的性能损耗。
优点是：既可以达到线程安全，也可以使性能不受很大的影响，换句话说在保证线程安全的前提下，既节省空间也节省了时间。

5.5、静态内部类

/**
 * Created by w1992wishes on 2017/11/2.
 */
public class Singleton {
    private Singleton(){}
    public static Singleton getInstance(){
        return SingletonHolder.sInstance;
    }
    private static class SingletonHolder{
        private static final Singleton sInstance = new Singleton();
    }
}

缺点是：与编程语言本身的特性相关，很多面向对象语言不支持。
优点是：由于静态单例对象没有作为Singleton的成员变量直接实例化，因此类加载时不会实例化Singleton，第一次调用getInstance()时将加载内部类SingletonHolder，在该内部类中定义了一个static类型的变量sInstance，此时会首先初始化这个成员变量，由Java虚拟机来保证其线程安全性，确保该成员变量只能初始化一次。由于getInstance()方法没有任何线程锁定，因此其性能不会造成任何影响。

5.6、枚举

/**
 * Created by w1992wishes on 2017/11/2.
 */
public enum Singleton {
    INSTANCE;//定义一个枚举的元素，它就是 Singleton 的一个实例
    public void doSomething(){}
}

使用如下：

public static void main(String args[]) {
	Singleton singleton = Singleton.instance;
	singleton.doSomeThing();
}

缺点是：大部分应用开发很少用枚举，可读性并不是很高。
优点是：使用枚举来实现单实例控制会更加简洁，而且无偿地提供了序列化机制，并由JVM从根本上提供保障，绝对防止多次实例化，是更简洁、高效、安全的实现单例的方式。

5.7、使用容器

/**
 * Created by w1992wishes on 2017/11/2.
 */
public class SingletonManager {
    private static Map<String, Object> cache = new HashMap<String, Object>();
    private SingletonManager(){}
    public static void registerInstance(String key, Object instance){
        if (!cache.containsKey(key)){
            cache.put(key, instance);
        }
    }
    public static Object getInstance(String key){
        return cache.get(key);
    }
}

这种是用SingletonManager 将多种单例类统一管理，在使用时根据key获取对象对应类型的对象。
缺点是：这也不是线程安全的，当然可以用ConcurrentHashMap改进。
优点是：这种方式使得我们可以管理多种类型的单例，并且在使用时可以通过统一的接口进行获取操作，降低了用户的使用成本，也对用户隐藏了具体实现，降低了耦合度。

六、优点和缺点

6.1、优点

单例模式提供了对唯一实例的受控访问。因为单例类封装了它的唯一实例，所以它可以严格控制客户怎样以及何时访问它。
由于在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能。
允许可变数目的实例。基于单例模式我们可以进行扩展，使用与单例控制相似的方法来获得指定个数的对象实例，既节省系统资源，又解决了单例单例对象共享过多有损性能的问题。

6.2、缺点

由于单例模式中没有抽象层，因此单例类的扩展有很大的困难。
单例类的职责过重，在一定程度上违背了“单一职责原则”。因为单例类既充当了工厂角色，提供了工厂方法，同时又充当了产品角色，包含一些业务方法，将产品的创建和产品的本身的功能融合到一起。
滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出。
现在很多面向对象语言(如Java、C#)的运行环境都提供了自动垃圾回收的技术，因此，如果实例化的共享对象长时间不被利用，系统会认为它是垃圾，会自动销毁并回收资源，下次利用时又将重新实例化，这将导致共享的单例对象状态的丢失。

七、适用环境

在以下情况下可以使用单例模式：

系统只需要一个实例对象，如系统要求提供一个唯一的序列号生成器，或者需要考虑资源消耗太大而只允许创建一个对象。
客户调用类的单个实例只允许使用一个公共访问点，除了该公共访问点，不能通过其他途径访问该实例。

在一个系统中要求一个类只有一个实例时才应当使用单例模式。反过来，如果一个类可以有几个实例共存，就需要对单例模式进行改进，使之成为多例模式。

八、模式应用

一个具有自动编号主键的表可以有多个用户同时使用，但数据库中只能有一个地方分配下一个主键编号，否则会出现主键重复，因此该主键编号生成器必须具备唯一性，可以通过单例模式来实现。

九、总结

单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。单例模式的要点有三个：一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。单例模式是一种对象创建型模式。
单例模式只包含一个单例角色：在单例类的内部实现只生成一个实例，同时它提供一个静态的工厂方法，让客户可以使用它的唯一实例；为了防止在外部对其实例化，将其构造函数设计为私有。
单例模式的目的是保证一个类仅有一个实例，并提供一个访问它的全局访问点。单例类拥有一个私有构造函数，确保用户无法通过new关键字直接实例化它。除此之外，该模式中包含一个静态私有成员变量与静态公有的工厂方法。该工厂方法负责检验实例的存在性并实例化自己，然后存储在静态成员变量中，以确保只有一个实例被创建。
单例模式的主要优点在于提供了对唯一实例的受控访问并可以节约系统资源；其主要缺点在于因为缺少抽象层而难以扩展，且单例类职责过重。
单例模式适用情况包括：系统只需要一个实例对象；客户调用类的单个实例只允许使用一个公共访问点。