1 场景分析

平常开发中，调用其他系统的接口是很常见的，调用一般需要用到一些配置信息，而这些配置信息一般在配置文件中，程序启动时读取到内存中使用。

例如有如下配置文件。

# 文件名 ThirdApp.properties
appId=188210
secret=MIVD587A12FE7E

程序直接读取配置文件，解析将配置信息保存在一个对象中，调用其他系统接口时使用这个对象即可。

package com.chenpi.singleton;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
/**
 * @Description 第三方系统相关配置信息
 * @Author 陈皮
 * @Date 2021/5/16
 * @Version 1.0
 */
public class ThirdConfig {
  private String appId;
  private String secret;
  public ThirdConfig() {
    // 初始化
    init();
  }
  /**
   * 读取配置文件，进行初始化
   */
  private void init() {
    Properties p = new Properties();
    InputStream in = ThirdConfig.class.getResourceAsStream("ThirdApp.properties");
    try {
      p.load(in);
      this.appId = p.getProperty("appId");
      this.secret = p.getProperty("secret");
    } catch (IOException e) {
      e.printStackTrace();
    } finally {
      try {
        if (null != in) {
          in.close();
        }
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
  }
  public String getAppId() {
    return appId;
  }
  public String getSecret() {
    return secret;
  }
}

使用的时候，直接创建对象，进行使用。

package com.chenpi.singleton;
/**
 * @Description
 * @Author 陈皮
 * @Date 2021/5/16
 * @Version 1.0
 */
public class ChenPiMain {
  public static void main(String[] args) {
    ThirdConfig thirdConfig = new ThirdConfig();
    System.out.println("appId=" + thirdConfig.getAppId());
    System.out.println("secret=" + thirdConfig.getSecret());
  }
}
// 输出结果如下
appId=1007
secret=陈皮的JavaLib

通过以上分析，需要使用配置信息时，只要获取 ThirdConfig 类的实例即可。但是如果项目是多人协作的，其他人使用这个配置信息的时候选择每次都去 new 一个新的实例，这样就会导致每次都会生成新的实例，并且重复读取配置文件的信息，多次 IO 操作，系统中存在多个 AppConfig 实例对象，严重浪费内存资源，如果配置文件内容很多的话，浪费系统资源更加严重。

针对以上问题，因为配置信息是不变的，共享的，所以我们只要保证系统运行期间，只有一个类实例存在就可以了。单例模式就用来解决类似这种问题的。

2 单例模式（Singleton）

在系统运行期间，一个类仅有一个实例，并提供一个对外访问这个实例的全局访问点。

将类的构造方法私有化，只能类自身来负责创建实例，并且只能创建一个实例，然后提供一个对外访问这个实例的静态方法，这就是单例模式的实现方式。

在 Java 中，单例模式的实现一般分为两种，懒汉式和饿汉式，它们之间主要的区别是在创建实例的时机上，一种是提前创建实例，一种是使用时才创建实例。

2.1 饿汉式

饿汉式、顾名思义，很饥饿很着急，所以在类加载器装载类的时候就创建实例，由 JVM 保证线程安全，只创建一次，饿汉式实现示例代码如下：

package com.chenpi.singleton;
/**
 * @Description 饿汉式单例模式
 * @Author 陈皮
 * @Date 2021/5/16
 * @Version 1.0
 */
public class HungerSingleton {
  /**
   * 提前实例化，由JVM保证实例化一次 使用static关键字修饰，使它在类加载器装载后，初始化此变量，并且能让静态方法getInstance使用
   */
  private static final HungerSingleton INSTANCE = new HungerSingleton();
  /**
   * 私有化构造方法，只能内部调用，外部调用不了则避免了多次实例化的问题
   */
  private HungerSingleton() {}
  /**
   * 外部访问这个类实例的方法，使用static关键字修饰，则外部可以直接通过类来调用这个方法
   *
   * @return HungerSingleton 实例
   */
  public static HungerSingleton getInstance() {
    return INSTANCE;
  }
}

2.2 懒汉式

懒汉式、顾名思义，既然懒就不着急，即等到要使用对象实例的时候才创建实例，更准确的说是延迟加载。懒汉式实现示例代码如下：

package com.chenpi.singleton;
/**
 * @Description 懒汉式单例模式
 * @Author 陈皮
 * @Date 2021/5/16
 * @Version 1.0
 */
public class LazySingleton {
  /**
   * 存储创建好的类实例，赋值null，使用时才创建赋值 因为静态方法getInstance使用了此变量，所以使用static关键字修饰
   */
  private static LazySingleton instance = null;
  /**
   * 私有化构造方法，只能内部调用，外部调用不了则避免了多次实例化的问题
   */
  private LazySingleton() {}
  /**
   * 外部访问这个类实例的方法，使用static关键字修饰，则外部可以直接通过类来调用这个方法
   *
   * @return LazySingleton 实例
   */
  public static LazySingleton getInstance() {
    // 判断实例是否存在
    if (instance == null) {
        instance = new LazySingleton();
    }
    // 如果已创建过，则直接使用
    return instance;
  }
}

3 优缺点比较

饿汉式，当类装载的时候就创建类实例，不管用不用，后续使用的时候直接获取即可，不需要判断是否已经创建，节省时间，典型的空间换时间。

懒汉式，等到使用的时候才创建类实例，每次获取实例都要进行判断是否已经创建，浪费时间，但是如果未使用前，则能达到节约内存空间的效果，典型的时间换空间。

从线程安全性上讲， 饿汉式是类加载器加载类到 JVM 内存中后，就实例化一个这个类的实例，由 JVM 保证了线程安全。而不加同步的懒汉式是线程不安全的，在并发的情况下可能会创建多个实例。

如果有两个线程 A 和 B，它们同时调用 getInstance 方法时，可能导致并发问题，如下：

public static LazySingleton getInstance() {
    // 判断对象实例是否已被创建
    if (instance == null) {
        // 线程A运行到这里了，正准备创建实例，或者实例还未创建完，
        // 此时线程B判断instance还是为null，则线程B也进入此，
        // 最终线程A和B都会创建自己的实例，从而出现了多实例
        instance = new LazySingleton();
    }
    // 如果已创建过，则直接使用
    return instance;
}

所以我们一般推荐饿汉式单例模式，因为由 JVM 实例化，保证了线程安全，实现简单。而且这个实例总会用到的时候，提前实例化准备好也未尝不可。

4 高级实现

4.1 双重检查加锁

前面说到，懒汉式单例模式在并发情况下可能会出现线程安全问题，那我们可以通过加锁，保证只能一个线程去创建实例即可，只要加上 synchronized 即可，如下所示：

public static synchronized LazySingleton getInstance() {
    // 判断对象实例是否已被创建
    if (instance == null) {
        // 第一次使用，没用被创建，则先创建对象，并且存储在类变量中
        instance = new LazySingleton();
    }
    // 如果已创建过，则直接使用
    return instance;
}

如果对整个方法加锁，会降低访问性能，即每次都要获取锁，才能进入执行方法。可以使用双重检查加锁的方式来实现，就可以既实现线程安全，又能够使性能不受到很大的影响。

双重检查加锁机制：每次进入方法不需要同步，进入方法后，先检查实例是否存在，如果不存在才进入加锁的同步块，这是第一重检查。进入同步块后，再次检查实例是否存在，如果不存在，就在同步的情况下创建一个实例，这是第二重检查。

使用双重检查加锁机制时，需要借助 volatile 关键字，被它修饰的变量，变量的值就不会被本地线程缓存，所有对该变量的读写都是直接操作共享内存，所以能确保多个线程能正确的处理该变量。

package com.chenpi.singleton;
/**
 * @Description 懒汉式单例模式
 * @Author 陈皮
 * @Date 2021/5/16
 * @Version 1.0
 */
public class LazySingleton {
  /**
   * 存储创建好的类实例，赋值null，使用时才创建赋值 因为静态方法getInstance使用了此变量，所以使用static关键字修饰
   */
  private volatile static LazySingleton instance = null;
  /**
   * 私有化构造方法，只能内部调用，外部调用不了则避免了多次实例化的问题
   */
  private LazySingleton() {
  }
  /**
   * 外部访问这个类实例的方法，使用static关键字修饰，则外部可以直接通过类来调用这个方法
   *
   * @return LazySingleton 实例
   */
  public static synchronized LazySingleton getInstance() {
    // 第一重检查，判断实例是否存在，如果不存在则进入同步块
    if (instance == null) {
      // 同步块，能保证同时只能有一个线程访问
      synchronized (LazySingleton.class) {
        // 第二重检查，保证只创建一次对象实例
        if (instance == null) {
          instance = new LazySingleton();
        }
      }
    }
    // 如果已创建过，则直接使用
    return instance;
  }
}

4.2 静态内部类实现

有一种方式，既有饿汉式的优点（线程安全），又有懒汉式的优点（延迟加载），那就是使用静态内部类。

何为静态内部类呢？即在类中定义的并且使用 static 修饰的类。可以认为静态内部类是外部类的静态成员，静态内部类对象与外部类对象间不存在依赖关系，因此可直接创建。

静态内部类中的静态方法可以使用外部类中的静态方法和静态变量；而且静态内部类只有在第一次被使用的时候才会被装载，达到了延迟加载的效果。然后我们在静态内部类中定义一个静态的外部类的对象，并进行初始化，由 JVM 保证线程安全，进行创建。

package com.chenpi.singleton;
/**
 * @Description 静态内部类实现单例模式
 * @Author Mr.nobody
 * @Date 2021/5/16
 * @Version 1.0
 */
public class StaticInnerClassSingleton {
  /**
   * 静态内部类，外部内未使用内部类时，类加载器不会加载内部类
   */
  private static class SingletonHolder {
    /**
     * 静态初始化，由JVM保证线程安全
     */
    private static final StaticInnerClassSingleton INSTANCE = new StaticInnerClassSingleton();
  }
  /**
   * 私有化构造方法
   */
  private StaticInnerClassSingleton() {
  }
  /**
   * 外部访问这个类实例的方法，使用static关键字修饰，则外部可以直接通过类来调用这个方法
   *
   * @return StaticInnerClassSingleton 实例
   */
  public static StaticInnerClassSingleton getInstance() {
    return SingletonHolder.INSTANCE;
  }
}

4.3 枚举实现

还有一种单例模式的最佳实现，就是借助枚举。实现简洁，高效安全。没有构造方法，还能防止反序列化，并由 JVM 保障单例。实例代码如下：

package com.chenpi.singleton;
/**
 * @Description 枚举实现单例模式，没有构造方法，能防止反序列化
 * @Author 陈皮
 * @Date 2021/5/16
 * @Version 1.0
 */
public enum EnumSingleton {
  /**
   * 定义一个枚举的元素，代表要实现类的一个实例
   */
  INSTANCE;
  // 可以定义方法
  public void test() {
    System.out.println("Hello ChenPi!");
  }
}

如果要使用，直接使用即可，如下：

package com.chenpi.singleton;
/**
 * @Description
 * @Author 陈皮
 * @Date 2021/5/16
 * @Version 1.0
 */
public class ChenPiMain {
  public static void main(String[] args) {
    EnumSingleton instance = EnumSingleton.INSTANCE;
    instance.test();
  }
}
// 输出结果
Hello ChenPi!

5 指定数量实例模式

单例模式，只有一个类实例。如果要求指定数量的类实例，例如指定2个或者3个，或者任意多个？

其实万变不离其宗，单例模式是只创建一个类实例，并且存储下来。那指定数量多例模式，就创建指定的数量类实例，也存储下来，使用时根据策略（例如轮询）取指定的实例即可。以下演示指定5个实例的情况：

package com.chenpi.singleton;
import java.util.HashMap;
import java.util.Map;
/**
 * @Description 指定数量的多实例模式
 * @Author 陈皮
 * @Date 2021/5/16
 * @Version 1.0
 */
public class ExtendSingleton {
  /**
   * 指定的实例数
   */
  private final static int INSTANCE_NUM = 5;
  /**
   * key前缀
   */
  private final static String PREFIX_KEY = "instance_";
  /**
   * 缓存实例的容器
   */
  private static Map<String, ExtendSingleton> map = new HashMap<>();
  /**
   * 记录当前正在使用第几个实例
   */
  private static int num = 1;
  /**
   * 私有化构造方法，只能内部调用，外部调用不了则避免了多次实例化的问题
   */
  private ExtendSingleton() {
  }
  /**
   * 外部访问这个类实例的方法，使用static关键字修饰，则外部可以直接通过类来调用这个方法
   *
   * @return ExtendSingleton 实例
   */
  public static ExtendSingleton getInstance() {
    // 缓存key
    String key = PREFIX_KEY + num;
    // 优先从缓存中取
    ExtendSingleton extendSingleton = map.get(key);
    // 如果指定key的实例不存在，则创建，并放入缓存容器中
    if (extendSingleton == null) {
      extendSingleton = new ExtendSingleton();
      map.put(key, extendSingleton);
    }
    // 当前实例的序号加1
    num++;
    if (num > INSTANCE_NUM) {
      // 实例的序号达到最大值重新从1开始
      num = 1;
    }
    return extendSingleton;
  }
}

本次分享到此结束啦~~

如果觉得文章对你有帮助，点赞、收藏、关注、评论，您的支持就是我创作最大的动力！

我是陈皮，一个在互联网 Coding 的 ITer，微信搜索「陈皮的JavaLib」第一时间阅读最新文章。