GOF23设计模式之单例模式

单例模式

1. 核心作用

   保证一个类只有一个实例，并且提供一个访问该实例的全局访问点

2. 常见应用场景

   项目中，读取配置文件的类，一般也只有一个对象。没有必要每次使用配置文件数据，每次new一个对象去读取。

   数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。

   在Spring MVC框架/struts1框架中，控制器对象也是单例

   在Spring中，每个Bean默认就是单例的，这样做的优点是Spring容器可以管理

   Windows的Task Manager（任务管理器）就是很典型的单例模式

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

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

3. 单例模式的优点：

   由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要 比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动 时直接产生一个单例对象，然后永久驻留内存的方式来解决

   单例模式可以在系统设置全局的访问点，优化环共享资源访问，例如可以设计 一个单例类，负责所有数据表的映射处理

4. 常见的五种单例模式实现方式：

   主要：

   饿汉式（线程安全，调用效率高。 但是，不能延时加载。）

   懒汉式（线程安全，调用效率不高。 但是，可以延时加载。）

   其他：

   双重检测锁式（由于JVM底层内部模型原因，偶尔会出问题。不建议使用）

   静态内部类式(线程安全，调用效率高。 但是，可以延时加载)

   枚举单例(线程安全，调用效率高，不能延时加载)

饿汉式实现（单例对象立即加载）

/**
 * 单例模式_应用场景_饿汉式
 * 特点: 1. 线程安全，不需要同步块。
 * 2. 方法没有同步，调用效率搞
 * @author YJ
 */
public class SingletonDemo1 {
    /** 类初始化时，立即加载这个对象 **/
    private static SingletonDemo1 instance = new SingletonDemo1();

    private SingletonDemo1(){
    }

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

懒汉式实现，单例对象延迟加载

/**
 * 懒汉式实现，单例对象延迟加载
 * 要点：
 *  lazy Load 延迟加载 ，懒加载！ 真正用的时候才加载！
 *  问题:
 *      “资源利用率高”，但是调用getInstance()方法都要同步，并发效率较低
 * @Author YJ
 */
public class SingletonDemo2 {
    private static SingletonDemo2 singletonDemo2;

    /**
     * 私有化构造器
     */
    public SingletonDemo2() {
    }

    /**
     * synchronized 同步 ，必须
     * 作用 ：当高并发时，如果A 在执行的过程中，B也执行了，可能会造成new 出两个对象（内存地址不一样）
     * @return
     */
    public static synchronized SingletonDemo2 getInstance(){
        if (singletonDemo2 == null){
            singletonDemo2 = new SingletonDemo2();
        }
        return singletonDemo2;
    }
}

双重检测锁

/**
 * 双重检测锁 实现单例模式
 * 这个模式将同步内容下方到if内部，提高了执行的效率 不必每次获取对象时都进行同步，只有第一次才同步 创建了以后就没必要了。
 * 问题：
 *  由于编译器优化原因和JVM底层内部模型原因，偶尔会出问题。不建议使用。
 * @Author YJ
 */
public class SingletonDemo3 {
    private static SingletonDemo3 instance = null;

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

    public SingletonDemo3() {

    }
}

静态内部类

/**
 * 静态内部类
 *  - 线程安全
 *  - 效率高
 *  - 懒加载
 * @author YJ
 */
public class SingletonDemo4 {

    private static class SingletonClassInstance{
        private static final SingletonDemo4 instance = new SingletonDemo4();
    }

    public static SingletonDemo4 getInstance(){
        return SingletonClassInstance.instance;
    }

    public SingletonDemo4() {

    }
}

枚举类实现单例模式（没有延迟加载）

public enum SingletonDemo5 {

    //这个枚举元素，本身就是单例对象！
    INSTANCE;

    //添加自己需要的操作
    public void singletonOperation(){

    }
}

测试

/**
 * 测试
 * @author YJ
 */
public class Client {
    public static void main(String[] args) {
        //1-4 种测试
        SingletonDemo3 instance = SingletonDemo3.getInstance();
        SingletonDemo3 instance2 = SingletonDemo3.getInstance();
        System.out.println(instance);
        System.out.println(instance2);
        //测试枚举方式
        System.out.println(SingletonDemo5.INSTANCE == SingletonDemo5.INSTANCE);
    }
}

如何选用?

• 单例对象 占用 资源少，不需要延时加载：

  枚举式 好于 饿汉式

• 单例对象 占用 资源 大，需要 延时加载：

  静态内部类式 好于 懒汉式