我是陈皮，一个在互联网 Coding 的 ITer，微信搜索「陈皮的 JavaLib」第一时间阅读最新文章，回复【资料】，即可获得我精心整理的技术资料，电子书籍，一线大厂面试资料和优秀简历模板。
1 场景分析
平常开发中，调用其他系统的接口是很常见的，调用一般需要用到一些配置信息，而这些配置信息一般在配置文件中，程序启动时读取到内存中使用。
例如有如下配置文件。
# 文件名 ThirdApp.propertiesappId=188210secret=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=1007secret=陈皮的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; }}
复制代码
本次分享到此结束啦~~
如果觉得文章对你有帮助，点赞、收藏、关注、评论，您的支持就是我创作最大的动力！
评论