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」第一时间阅读最新文章。