单例模式

单例模式要点

• 一、是某个类只能有一个实例；

构造器私有化

• 二、是它必须自行创建这个实例；

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

• 三、是它必须自行向整个系统提供这个实例；

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

饿汉式：直接创建对象，不存在线程安全问题

• 一、直接实例化

/**
 * 饿汉式
 *  直接创建实例对象，不管是否需要这个实例
 *
 * 1、构造器私有化
 * 2、自行创建，并用静态变量保存
 * 3、向外提供这个实例
 * 4、强调是单例，使用final 修饰
 */
public class Singleton1 {

    public static final Singleton1 SINGLETON = new Singleton1();

    private Singleton1(){

    }
}

• 二、枚举

/**
 * 枚举类型
 */
public enum  Singleton2 {
    SINGLETON
}

• 三、静态代码

/**
 * 静态代码块 适合复杂实例化
 *
 * 类中有其他属性
 */
public class Singleton3 {
    public static final Singleton3 SINGLETON;
    private String info;

    static {
        try {
            Properties pro = new Properties();
            //single.properties  在resources 目录下 使用类加载器进行加载
            pro.load(Singleton3.class.getClassLoader().getResourceAsStream("single.properties"));
            SINGLETON = new Singleton3(pro.getProperty("info"));
        }catch (Exception e){
            throw new RuntimeException(e);
        }
    }

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

    public String getInfo() {
        return info;
    }

    public void setInfo(String info) {
        this.info = info;
    }

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

懒汉式：延迟创建对象

• 一、线程不安全

 

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

    private static Singleton4 singleton;

    private Singleton4(){

    }

    public static Singleton4 getSingleton(){
        if (singleton == null){
            singleton = new Singleton4();
        }
        return singleton;
    }

}

• 二、线程安全

/**
 * 懒汉式
 * 延迟创建这个实例对象
 *
 * 1、构造器私有化
 * 2、用一个静态变量保存这个实例
 * 3、提供一个静态方法，获取实例对象
 *
 * 适用多线程程模式
 */
public class Singleton5 {

    private static Singleton5 singleton;

    private Singleton5(){

    }

    public static Singleton5 getSingleton(){
        //提升效率
        if(singleton == null) {
            //同步
            synchronized (Singleton5.class) {
                if (singleton == null) {
                    singleton = new Singleton5();
                }
            }
        }
        return singleton;
    }

}

• 三、静态内部类

/**
 * 懒汉式
 * 延迟创建这个实例对象
 *
 * 静态内部类加载和初始化时，才会创建SINGLETON实例对象
 * 静态内部类不会随着外部类的加载和初始化而初始化，是要单独去加载和初始化
 *
 * 线程安全
 */
public class Singleton6 {


    private Singleton6(){

    }

    private static class Inner{
        private static final Singleton6 SINGLETON = new Singleton6();
    }

    public static Singleton6 getSingleton(){
        return Inner.SINGLETON;
    }

}