package com.nobody.singleton;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

/**
 * @Description 第三方系统相关配置信息
 * @Author Mr.nobody
 * @Date 2021/5/16
 * @Version 1.0
 */
public class ThirdConfig {

    /**
     * 应用ID
     */
    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();
            }
        }
    }

    // 省略get/set方法
}

简单测试一下，示例如下：

package com.nobody.singleton;

/**
 * @Description
 * @Author Mr.nobody
 * @Date 2021/5/16
 * @Version 1.0
 */
public class Main {

    public static void main(String[] args) {
        ThirdConfig thirdConfig = new ThirdConfig();
        System.out.println("appId=" + thirdConfig.getAppId());
        System.out.println("secret=" + thirdConfig.getSecret());
    }
}
// 输出结果如下
appId=188210
secret=MIVD587A12FE7E

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

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

2 单例模式（Singleton）

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

如果一个类的构造方法不对外公开，仅让类自身来负责自己类实例的创建工作，并且只创建一个实例，然后提供一个对外访问这个实例的方法，这就是单例模式的实现方式。

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

2.1 饿汉式

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

package com.nobody.singleton;

/**
 * @Description 饿汉式单例模式
 * @Author Mr.nobody
 * @Date 2021/5/16
 * @Version 1.0
 */
public class HungerSingleton {
    /**
     * 存储创建好的类实例，提前实例化，并且由JVM保证创建一次
     * 使用static关键字修饰，使它在类加载器装载后，初始化此变量，并且能让静态方法getInstance使用
     */
    private static HungerSingleton instance = new HungerSingleton();

    /**
     * 私有化构造方法，只能内部调用，外部调用不了则避免了多次实例化的问题
     */
    private HungerSingleton() {}

    /**
     * 外部访问这个类实例的方法，使用static关键字修饰，则外部可以直接通过类来调用这个方法
     * 
     * @return HungerSingleton 实例
     */
    public static HungerSingleton getInstance() {
        return instance;
    }
}

2.2 懒汉式

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

package com.nobody.singleton;

/**
 * @Description 懒汉式单例模式
 * @Author Mr.nobody
 * @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 方法时，可能导致并发问题，如下：

/**
 * 外部访问这个类实例的方法，使用static关键字修饰，则外部可以直接通过类来调用这个方法
 *
 * @return LazySingleton 实例
 */
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.nobody.singleton;

/**
 * @Description 懒汉式单例模式
 * @Author Mr.nobody
 * @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.nobody.singleton;

/**
 * @Description 静态内部类实现单例模式
 * @Author Mr.nobody
 * @Date 2021/5/16
 * @Version 1.0
 */
public class StaticInnerClassSingleton {

    /**
     * 静态内部类
     */
    private static class SingletonHolder {
        /**
         * 静态初始化，由JVM保证线程安全
         */
        private static StaticInnerClassSingleton instance = new StaticInnerClassSingleton();
    }

    /**
     * 私有化构造方法
     */
    private StaticInnerClassSingleton() {}

    /**
     * 外部访问这个类实例的方法，使用static关键字修饰，则外部可以直接通过类来调用这个方法
     *
     * @return StaticInnerClassSingleton 实例
     */
    public static StaticInnerClassSingleton getInstance() {
        return SingletonHolder.instance;
    }
}

4.3 枚举实现

还有一种单例模式的最佳实现，就是借助枚举。实现简洁，而且无偿地提供了序列化的机制，并由 JVM 从根本上提供保障，绝对防止多次实例化，是更简洁、高效、安全的实现单例的方式。实例代码如下：

package com.nobody.singleton;

/**
 * @Description 枚举实现单例模式
 * @Author Mr.nobody
 * @Date 2021/5/16
 * @Version 1.0
 */
public enum EnumSingleton {
    /**
     * 定义一个枚举的元素，代表要实现类的一个实例
     */
    instance;

}

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

package com.nobody.singleton;

/**
 * @Description
 * @Author Mr.nobody
 * @Date 2021/5/16
 * @Version 1.0
 */
public class Main {

    public static void main(String[] args) {

        EnumSingleton enumSingleton = EnumSingleton.instance;
    }
}

5 指定数量实例模式

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

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

package com.nobody.singleton;

import java.util.HashMap;
import java.util.Map;

/**
 * @Description 指定数量的多实例模式
 * @Author Mr.nobody
 * @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;
    }
}