设计模式 - 单例模式

0x01 懒汉式

public class LazySingleton {

    private static LazySingleton instance;

    // 私有构造方法，防止外部创建对象
    private LazySingleton() {
    }

    public static synchronized LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

• 优点：延时加载，不会浪费资源
• 缺点：为了保证线程安全加锁了，多线程环境下性能降低

0x02 饿汉式

public class EagerSingleton {

    private static final EagerSingleton instance = new EagerSingleton();

    public static EagerSingleton getInstance() {
        return instance;
    }
}

• 优点：类加载时创建实例，对象唯一，线程安全
• 缺点：类加载时就创建了，占用系统资源

0x03 双重检查锁

public class DoubleCheckSingleton {

    private static volatile DoubleCheckSingleton instance;

    // 私有构造方法，防止外部创建对象
    private DoubleCheckSingleton() {
    }

    public static DoubleCheckSingleton getInstance() {
        if (instance == null) {// 步骤1
            synchronized (DoubleCheckSingleton.class) {// 步骤2
                if (instance == null) {// 步骤3
                    instance = new DoubleCheckSingleton();// 步骤4
                }
            }
        }
        return instance;
    }
}

综合了经典的饿汉式和懒汉式的优点，但是有几点需要注意：

• 步骤3的 if 判断不可缺少

  多线程环境下，线程A、B都进行到步骤2，其中线程A获得锁，进行实例化，完成后释放锁，线程B获得锁，此时若没有步骤3，则线程B将继续实例化 instance ，导致出现多个实例

• volatile 关键字不可缺少，因为步骤4并非原子操作，涉及多步

  • 1、为 instance 分配内存空间

  • 2、初始化 instance

  • 3、内存地址赋值给实例 instance

    若不加 volatile 修饰，JVM会进行一些优化，可能以上三步执行顺便发生变化（如：1、3、2），此时对象尚未初始化完成，但是已经返回，会造成使用者出现错误，所以 volatile 关键字必要，不过这里用final代替volatile，效果一样，因为final修饰的变量，在构造方法执行完成之前，不会返回该对象实例，不会出现上面的情况

0x04 静态内部类

public class StaticHolderSingleton {

    // 私有构造方法，防止外部创建对象
    private StaticHolderSingleton() {
    }

    private static class Holder {
        private static final StaticHolderSingleton INSTANCE = new StaticHolderSingleton();
    }

    public static StaticHolderSingleton getInstance() {
        return Holder.INSTANCE;
    }
}

当 StaticHolderSingleton 类加载时，静态内部类 Holder 没有被加载进内存。只有当调用 getInstance() 方法从而触发 Holder.INSTANCE 时 Holder 才会被加载，此时初始化 INSTANCE 实例，并且 JVM 能确保 INSTANCE 只被实例化一次。这种方式不仅具有延迟初始化的好处，而且由 JVM 提供了对线程安全的支持。

0x05 枚举

该实现在多次序列化再进行反序列化之后，不会得到多个实例
该实现是由 JVM 保证只会实例化一次，因此不会出现上述的反射攻击