设计模式 - 单例模式

1. 什么是单例模式

单例模式，某类在整个程序有且仅有一个实例。该类负责创建自己的对象，同时确保只有一个对象被创建。在Java，一般常用在工具类的实现或创建对象需要消耗资源。

单例模式的特点

• 某个类只能有一个实例(构造器私有化)
• 它必须自行创建这个实例(含有一个改类的静态变量来保存这个唯一的实例)
• 自行向整个系统提供这个实例(直接暴露或者用静态变量的get方法)

2. 单例模式的应用场景

适用场景

1. 需要生成唯一序列的环境
2. 需要频繁实例化然后销毁的对象
3. 创建对象时耗时过多或者耗资源过多，但又经常用到的对象
4. 方便资源相互通信的环境

比如

1. Windows的Task Manager（任务管理器）就是很典型的单例模式（这个很熟悉吧），想想看，是不是呢，你能打开两个windows task manager吗？ 不信你自己试试看哦~

2. windows的Recycle Bin（回收站）也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。

3. 网站的计数器，一般也是采用单例模式实现，否则难以同步。

4. 应用程序的日志应用，一般都何用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。

5. Web应用的配置对象的读取，一般也应用单例模式，这个是由于配置文件是共享的资源。

6. 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。数据库软件系统中使用数据库连接池，主要是节省打开或者关闭数据库连接所引起的效率损耗，这种效率上的损耗还是非常昂贵的，因为何用单例模式来维护，就可以大大降低这种损耗。

7. 多线程的线程池的设计一般也是采用单例模式，这是由于线程池要方便对池中的线程进行控制。

8. 操作系统的文件系统，也是大的单例模式实现的具体例子，一个操作系统只能有一个文件系统。

9. HttpApplication 也是单位例的典型应用。熟悉ASP.Net(IIS)的整个请求生命周期的人应该知道HttpApplication也是单例模式，所有的HttpModule都共享一个HttpApplication实例.

3. 单例模式的优缺点

优点

• 在内存中只有一个对象，节省内存空间
• 避免频繁的创建销毁对象，可以提高性能
• 避免对共享资源的多重占用，简化访问
• 为整个系统提供一个全局访问点

缺点

• 不适用于变化频繁的对象
• 滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出
• 如果实例化的对象长时间不被利用，系统会认为该对象是垃圾而被回收，这可能会导致对象状态的丢失

4. 单例模式的实现方式

饿汉式

public class Singleton1 {
    private static final Singleton1 INSTANCE = new Singleton1();
    
    private Singleton1() {
    }
    
    public static Singleton1 getInstance() {
        return INSTANCE;
    }
}

类加载到内存后，就实例化一个单例，JVM保证线程安全，缺点：不管用到与否，类装载时就完成实例化。

懒汉式

public class Singleton2 {
    private static Singleton2 INSTANCE;

    private Singleton2() {
    }

    public static Singleton2 getInstance() {
        if (null == INSTANCE) {
            INSTANCE = new Singleton2();
        }
        return INSTANCE;
    }
}

按需加载，理想情况下：第一次获取实例的时候，实例为空，那么就会进行一次初始化；第二次获取实例时，由于在第一次获取时已经实例化过了，所以直接返回。

但是这样会带来线程不安全的问题，在并发情况下，可能会产生多个实例。下面举个例子：

public class Singleton2 {
    private static Singleton2 INSTANCE;

    private Singleton2() {
    }

    public static Singleton2 getInstance() {
        if (null == INSTANCE) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new Singleton2();
        }
        return INSTANCE;
    }

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

这里创建100个线程，但是线程执行速度很快，为了更好地体现出“可能产生多个实例”，我在实例化过程中加了个线程休眠用来打断其他线程，这样能更容易看出代码的问题。执行之后可以发现，确实出现了多个实例的情况。

那么，有如下方法解决懒汉式带来的线程不安全问题：

1. 在getInstance()方法上加同步锁

public static synchronized Singleton2 getInstance() {
    if (null == INSTANCE) {
        INSTANCE = new Singleton2();
    }
    return INSTANCE;
}

用synchronized修饰一下该方法，但是加了锁之后，它的效率会降低，因为每次获取实例的时候，都会进行加锁的操作，要看有没有申请这把锁，才能进行操作。synchronized锁定的是当前对象，但是这里还有个static关键字，所以锁定的当前类的class对象）

2. 双重检查

public static Singleton2 getInstance() {
    if (null == INSTANCE) {
        synchronized (Singleton2.class) {
            if (null == INSTANCE) {
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                INSTANCE = new Singleton2();
            }
        }
    }
    return INSTANCE;
}

首先判断INSTANCE是否为空，如果是的话，就上锁，上锁之后再判断是否为空；如果在上锁之前，已经有其他线程进行了实例化，那么第二次if就不会执行了，直接返回INSTANCE。

静态内部类

public class Singleton3 {
    private Singleton3() {
    }

    private static class Singleton3Internal {
        private static final Singleton3 INSTANCE = new Singleton3();
    }

    public static Singleton3 getInstance() {
        return Singleton3Internal.INSTANCE;
    }
}

在Singleton3中定义一个静态内部类Singleton3Internal作为它的持有者，在静态内部类中初始化实例。

由于Singleton3的构造方法为private，所以只有在内部类中才能访问，外部类无法new；当外部调用getInstance()方法时，返回的是内部类中的实例。

这种方法要比饿汉式好，因为外部类Singleton3加载时，内部类Singleton3Internal并不会被初始化，只有在调用getInstance()方法的时候才会被加载，这样就实现了懒加载，而且保证了只有一个实例。

这个线程安全是由JVM来保证的，因为JVM加载一个class的时候只加载一次，所以内部类Singleton3Internal也只加载一次，里面的INSTANCE也只加载一次，它永远只有一个对象。

枚举

public enum Singleton4 {
    INSTANCE;
}

这是Java创始人之一Joshua Bloch在他的书中《Effective Java》，提到的一种单例的写法。简单粗暴，用了一个枚举类，里面只有一个取值，就是INSTANCE。

每个枚举类型及其定义的枚举变量在JVM中都是唯一的，这样不仅可以解决线程同步问题，还可以防止反序列化。