【单例设计模式之懒汉式与饿汉式】

单例设计模式之懒汉式与饿汉式

要点

• 某个类只能有一个实例
  • 构造器私有化
• 必须自行创建这个实例
  • 含有一个该类的静态变量来保存这个唯一实例
• 必须自行向整个系统提供这个实例
  • 对外提供获取该实例对象的方式：
    • 直接暴露
    • 用静态变量的get方式获取

几种常见形式

• 饿汉式：直接创建对象，不存在线程安全问题
  • 直接实例化饿汉式（简洁直观）
  • 枚举式（最简单）
  • 静态代码块饿汉式（适合复杂实例化）
• 懒汉式：延迟创建对象
  • 线程不安全（适用于单线程）
  • 线程安全（适用于多线程）
  • 静态内部类形式（适用于多线程）

饿汉式

/**
 * 饿汉式
 * 在类初始化时直接创建实例对象，不管是否需要都会创建
 * 
 * 1.构造器私有化
 * 2.自行创建，并且用静态变量保存
 * 3.向外提供这个石林
 * 4.强调这个是一个单例，可以用final修饰
 */
public class Singleton1 {
    public static final Singleton1 INSTANCE = new Singleton1();
    private Singleton1() {
    }
}

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

/**
 * 静态代码块饿汉式（适合复杂实例化）
 */
public class Singleton3 {
    public static final Singleton3 INSTANCE;
    private String info;

    static {
        Properties properties = new Properties();
        try {
            properties.load(
                    Singleton3.class.getClassLoader()
                            .getResourceAsStream("bean.properties"));
            INSTANCE = new Singleton3(properties.getProperty("info"));
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public Singleton3(String info) {
        this.info = info;
    }

    @Override
    public String toString() {
        return "Singleton3{" +
                "info='" + info + '\'' +
                '}';
    }
}

懒汉式

/**
 * 懒汉式-线程不安全（适用于单线程）
 *  延迟创建这个实例对象
 *  1.构造器私有化
 *  2.用一个静态变量保存这个唯一的实例
 *  3.提供一个静态方法，获取这个实例对象
 */
public class Singleton4 {
    private static Singleton4 instance;

    public Singleton4() {
    }

    public static Singleton4 getInstance() {
        if (instance == null) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            instance = new Singleton4();
        }
        return instance;
    }
}

/**
 * 懒汉式--线程安全
 *  延迟创建这个实例对象
 *  1.构造器私有化
 *  2.用一个静态变量保存这个唯一的实例
 *  3。提供一个静态方法，获取这个实例对象
 */
public class Singleton5 {
    private static Singleton5 instance;

    public Singleton5() {
    }

    public static Singleton5 getInstance() {
        if (instance == null) {
            synchronized (Singleton5.class) {
                if (instance == null) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    instance = new Singleton5();
                }
            }
        }
        return instance;
    }
}

/**
 * 懒汉式
 * 在内部类被加载和初始化时，才创建INSTANCE实例对象
 * 静态内部类不会自动随着外部类的加载和初始化而初始化，他是要单独去加载和初始化的
 * 因为时在内部类加载和初始化时创建的，因此是线程安全的
 */
public class Singleton6 {

    public Singleton6() {
    }
    
    private static class Inner{
        private static final Singleton6 INSTANCE = new Singleton6();
    }
    
    public static Singleton6 getInstance() {
        return Inner.INSTANCE;
    }
}