概念

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

特点

1、单例类只能有一个实例。

2、单例类必须自己创建自己的唯一实例。

3、单例类必须给所有其他对象提供这一实例。

懒汉式，线程不安全

/**
 * 懒汉式，线程不安全
 */
public class AcctConfig {

    private static final String FILE_NAME = "singleton.properties";

    private static AcctConfig INSTANCE;

    private final Properties properties;

    private AcctConfig() {
        properties = new Properties();
        try (InputStream fis = AcctConfig.class.getResourceAsStream(FILE_NAME)) {
            properties.load(fis);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static AcctConfig getInstance() {
        if (Objects.nonNull(INSTANCE)) {
            return INSTANCE;
        }
        INSTANCE = new AcctConfig();
        return INSTANCE;
    }

    public String getProperty(String propertyName) {
        return properties.getProperty(propertyName);
    }
}

如果多线程并发，会导致Objects.nonNull判断失误，创建多个实例

懒汉式，线程安全

/**
 * 懒汉式，线程安全
 */
public class AcctConfig {

    // 略
  
    public static synchronized AcctConfig getInstance() {
        if (Objects.nonNull(INSTANCE)) {
            return INSTANCE;
        }
        INSTANCE = new AcctConfig();
        return INSTANCE;
    }
  
    // 略
}

最粗暴的方式就是在getInstance方法上加上synchronized关键字

双检锁

/**
 * 懒汉式，双检锁
 */
public class AcctConfig {

    // 略
    // volatile 这里主要用于指令重排序
    private static volatile AcctConfig INSTANCE;
  
    public static AcctConfig getInstance() {
        if (Objects.nonNull(INSTANCE)) {
            return INSTANCE;
        }

        synchronized (AcctConfig.class) {
            if (Objects.nonNull(INSTANCE)) {
                return instance;
            }

            INSTANCE = new AcctConfig();
            return INSTANCE;
        }
    }
  
    // 略
}

直接在getInstance方法上添加synchronized关键字过于粗暴，大多数场景下instance已经被实例化好了，不需要加锁。所以可以考虑使用双检锁。

饿汉式

/**
 * 饿汉式
 */
public class AcctConfig {

    private static final String FILE_NAME = "singleton.properties";

    private static final AcctConfig INSTANCE = new AcctConfig();

    private final Properties properties;

    private AcctConfig() {
        properties = new Properties();
        try (InputStream fis = AcctConfig.class.getResourceAsStream(FILE_NAME)) {
            properties.load(fis);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static AcctConfig getInstance() {
        return INSTANCE;
    }

    public String getProperty(String propertyName) {
        return properties.getProperty(propertyName);
    }
}

饿汉式是线程安全的，这一点由类的加载器保证的。

登记式/静态内部类

/**
 * 登记式/静态内部类
 */
public class AcctConfig {

    private static class AcctConfigHolder {
        private static final AcctConfig INSTANCE = new AcctConfig();
    }

    private static final String FILE_NAME = "singleton.properties";

    private final Properties properties;

    private AcctConfig() {
        properties = new Properties();
        try (InputStream fis = AcctConfig.class.getResourceAsStream(FILE_NAME)) {
            properties.load(fis);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static AcctConfig getInstance() {
        return AcctConfigHolder.INSTANCE;
    }

    public String getProperty(String propertyName) {
        return properties.getProperty(propertyName);
    }
}

将INSTANCE通过静态内部类AcctConfigHolder持有，可以达到懒加载的目的。第一次调用getInstance方法时，AcctConfigHolder类才会被加载到内存中，从而初始化INSTANCE对象。

枚举方式

/**
 * 枚举方式
 */
public enum AcctConfig {

    INSTANCE;

    private static final String FILE_NAME = "singleton.properties";

    private final Properties properties;

    private AcctConfig() {
        properties = new Properties();
        try (InputStream fis = AcctConfig.class.getResourceAsStream(FILE_NAME)) {
            properties.load(fis);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static AcctConfig getInstance() {
        return INSTANCE;
    }

    public String getProperty(String propertyName) {
        return properties.getProperty(propertyName);
    }
}

这种方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。