详解设计模式：单例模式

public class Singleton {

    /**
     * 定义一个变量来存储创建好的实例，直接在这里创建实例，只能创建一次，
     * static 变量在类加载时进行初始化，并且只被初始化一次。
     */
    private static final Singleton INSTANCE = new Singleton();

    /**
     * 私有化构造方法，可以在内部控制创建实例的数目，防止在外部创建
     */
    private Singleton() {
    }

    /**
     * 定义一个方法为客户端提供类实例，方法上加static将该方法变为静态，目的是不需要对象实例就可以在外部直接通过类来调用
     */
    public static Singleton getInstance() {
        // 直接使用已经创建好的实例
        return INSTANCE;
    }

}

public class Singleton {

    /**
     * 在成员位置创建该类的对象
     */
    private static final Singleton INSTANCE;

    /**
     * 私有构造方法
     */
    private Singleton() {
    }
    
    static {
        //  静态代码块随着类的加载而加载，并且只加载一次，它的优先级与静态成员变量一致，谁先声明谁就先执行
        INSTANCE = new Singleton();
    }

    /**
     * 对外提供静态方法获取该对象
     */
    public static Singleton getInstance() {
        return INSTANCE;
    }
}

public enum Singleton {

    /**
     * Java 的枚举类型实质上时功能齐全的类，因此可以有自己的属性和方法
     * 定义一个枚举的元素，它就代表了 Singleton 的一个实例
     */
    INSTANCE;

    /**
     * 单例自己的操作函数
     */
    public void singletonOperation() {
        // 功能处理
    }

}

public class Singleton {

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

    /**
     * 在成员位置声明Singleton类型的静态变量，并没有进行对象的赋值操作
     */
    private static Singleton instance;

    /**
     * 当调用 getInstance() 方法获取 Singleton 类的对象的时候才创建 Singleton 类的对象，这样就实现了懒加载的效果。
     *
     * @return Singleton
     */
    public static Singleton getInstance() {

        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

public class Singleton {

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

    /**
     * 在成员位置创建该类的对象
     */
    private static Singleton instance;

    /**
     * 对外提供静态方法获取该对象，加了synchronized关键字，线程安全（但是导致该方法的执行效果特别低）
     *
     * @return Singleton
     */
    public static synchronized Singleton getInstance() {

        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

public class Singleton {

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

    /**
     * 在成员位置创建该类的对象
     * 使用 volatile ：避免 JVM 在实例化对象的时候会进行优化和指令重排序操作而导致空指针问题
     */
    private static volatile Singleton instance;

    /**
     * 对外提供静态方法获取该对象
     *
     * @return Singleton
     */
    public static Singleton getInstance() {
        // 第一次判断，如果instance不为null，不进入抢锁阶段，直接返回实例
        if (instance == null) {
            synchronized (Singleton.class) {
                // 抢到锁之后再次判断是否为null
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

public class Singleton {

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

    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    /**
     * 对外提供静态方法获取该对象
     * 第一次加载 Singleton 类时不会去初始化 INSTANCE，只有第一次调用 getInstance，虚拟机加载 SingletonHolder，初始化 INSTANCE
     * 这样不仅能确保线程安全，也能保证 Singleton 类的唯一性
     *
     * @return Singleton
     */
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}