单例模式（Singleton Pattern）

23种设计模式系列目录

23种设计模式之单例模式（Singleton Pattern）

23种设计模式之代理模式（Proxy Pattern）

23种设计模式之适配器模式（Adapter Pattern）

23种设计模式之工厂模式（Factory Pattern）

23种设计模式之抽象工厂模式（Abstract Factory Pattern）

23种设计模式之装饰器模式（Decorator Pattern）

--------------------------------------------------------------------------------------------------------------------------

读完本篇文章将会了解以下问题

1. 单例模式定义

2. 单例模式代码实现

3. 单例模式优缺点

4. 单例模式应用举例

--------------------------------------------------------------------------------------------------------------------------

一、单例模式定义

1.1 单例模式概述：

      单例模式是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

1.2 单例模式要点：

      目的：保证一个类只能有一个实例，而且自行实例化并向整个系统提供这个实例，避免频繁创建对象，节约内存。

      主要解决：一个全局使用的类频繁地创建与销毁。

      何时使用：当想控制实例数目，节省系统资源时。

      如何解决：判断系统是否已经持有这个单例，如果有则返回，如果没有则创建。

      关键代码：构造函数私有化。

二、单例模式代码实现

2.1 饿汉式

       饿汉式：在类加载时就完成了初始化，避免了多线程同步问题，获取对象的速度快。但因为类加载时就被实例化了，导致类加载比较慢，而且如果该实例没有被使用，内存空间就白白浪费了。

public class Singleton {

    private final static Singleton INSTANCE = new Singleton();
    
    private Singleton(){}

    public static Singleton getInstance(){
        return INSTANCE;
    }
}

2.2 懒汉式     

       懒汉式：在类加载时不初始化，等到第一次被使用时才初始化

Demo1：

public class Singleton {

    private static Singleton instance = null;

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

       简单的懒汉式写法，存在多线程安全问题。如果多个线程同时访问，有可能出现对象多次实例化。

public class Singleton {

    private static Singleton instance = null;

    private Singleton() {
    }

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

       同步懒汉式：对getInstance()方法加synchronize，保证了同一时刻只能有一个线程访问并获得实例。缺点：synchronized修饰整个方法，每个线程访问都要进行同步，而这个方法只执行一次实例化代码就够了，每次都同步方法显然效率低下。

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;
    }
}

       双重检查懒汉式：为什么要做两次判断？当对象还没实例化时，两个线程A和B同时访问静态方法并同时运行到第一个if判断语句，这时线程A先进入同步代码块中实例化对象，结束之后线程B也进入同步代码块，如果没有第二个if判断语句，那么线程B也同样会执行实例化对象的操作。

public class Singleton {

    private Singleton() {}

    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

       静态内部类懒汉式：这种静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingletonInstance类，从而完成对象的实例化。同时，因为类的静态属性只会在第一次加载类的时候初始化，也就保证了SingletonInstance中的对象只会被实例化一次，并且这个过程也是线程安全的。

三、单例模式优缺点

单例模式优点：

       1、单例类只有一个实例，节省了内存资源，对于一些需要频繁创建销毁的对象，从而提高系统性能。

       2、单例模式可以在系统设置全局的访问点，优化和共享数据。

       3、避免对资源的多重占用。

单例模式缺点：

       1、没有接口，不能继承，与单一职责原则冲突（一个类应该只关心内部逻辑，而不关心外面怎么样来实例化），导致扩展的话除了修改代码基本上没有其他途径。

四、单例模式应用举例

       1、要求生产唯一序列号。

       2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。

       3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

 

借鉴博文：https://blog.csdn.net/yeyazhishang/article/details/90445330

                  https://www.runoob.com/design-pattern/singleton-pattern.html