1 什么是Singleton？

1.1 Singleton

在Java中即指单例设计模式，它是软件开发中最常用的设计模式之一。

• 单：唯一
• 例：实例

1.2 单例设计模式

即某个类在整个系统中只能有一个实例对象可被获取和使用的代码模式。

• 例如：代表JVM运行环境的Runtime类

2 要点

2.1 只能有一个实例

• 构造器私有化

2.2 必须自行创建这个实例

• 含有一个该类的静态变量来保存这个唯一的实例

2.3 必须自行向整个系统提供这个实例

• 对外提供获取该实例对象的方式：
  • 直接暴露
  • 用静态变量的get方法获取

3 几种常见形式

3.1 饿汉式

在类初始化时直接创建对象，不存在线程安全问题

• 直接实例化饿汉式（简洁直观）

    /**
     * 饿汉式：
     * 直接创建实例对象，不管你是否需要这个对象都会创建
     * （1）构造器私有化
     * （2）自行创建，并且用静态变量保存
     * （3）向外提供这个实例
     * （4）强调这是一个单例，我们可以用final修改
     */
    public class Singleton {
        public static final Singleton INSTANCE = new Singleton();
        private Singleton() {}
    }

• 枚举式（最简洁）

    /**
     * 枚举类型，表示该类型的对象是有限的几个
     * 我们可以限定为一个，就成了单例
     */
    public enum Singleton {
        INSTANCE
    }

• 静态代码块饿汉式（适合复杂实例化）

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

    import java.io.IOException;
    import java.util.Properties;
  
    public class Singleton {
        public static final Singleton INSTANCE;
        private String info;
        static {
            try {
                Properties pro = new Properties();
                pro.load(Singleton.class.getClassLoader().getResourceAsStream("single.properties"));
                INSTANCE = new Singleton(pro.getProperty("info"));
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        private Singleton(String info) {
            this.info = info;
        }
    }

  3.2 懒汉式

延迟创建对象

• 线程不安全（适用于单线程）

    /**
     * 懒汉式：
     *  延迟创建这个实例对象
     * （1）构造器私有化
     * （2）用一个静态变量保存这个唯一的实例
     * （3）提供一个静态方法，获取这个实例对象
     */
    public class Singleton {
        private static Singleton instance;
        private Singleton() {}
        public static Singleton getInstance() {
            if (instance == null) {
                instance = new Singleton();
            }
            return instance;
        }
    }

• 线程安全（适用于多线程）

    /**
     * 懒汉式：
     *  延迟创建这个实例对象
     * （1）构造器私有化
     * （2）用一个静态变量保存这个唯一的实例
     * （3）提供一个静态方法，获取这个实例对象
     */
    public class Singleton {
        private static Singleton instance;
        private Singleton() {}
        public static Singleton getInstance() {
            if (instance == null) {
                synchronized (Singleton.class) {
                    if (instance == null) {
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }
    }

• 静态内部类形式（适用于多线程）

    /**
     * 在内部类被加载和初始化时，才创建INSTANCE实例对象
     * 静态内部类不会自动随着外部类的加载和初始化而初始化，它是要单独去加载和初始化的
     * 因为是在内部类加载和初始化时创建的，因此是线程安全的
     */
    public class Singleton {
        private Singleton() {}
        private static class Inner {
            private static final Singleton INSTANCE = new Singleton();
        }
        public static Singleton getInstance() {
            return Inner.INSTANCE;
        }
    }

  4 小结

• 如果是饿汉式，枚举式是最简洁的

• 如果是懒汉式，静态内部类是最简洁的