【Java面试题】单例设计模式

什么单例设计模式

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

单例模式常见形式

　　1、饿汉式：直接创建对象，不存在线程安全问题
　　　　直接实例化饿汉式（简介直观）
　　　　枚举式（最简洁）
　　　　静态代码块饿汉式（适合复杂实例化）

　　2、懒汉式：延迟创建对象
　　　　线程不安全（适合于单线程）
　　　　线程安全（适合于多线程）
　　　　静态内部类形式（适用于多线程）

饿汉式

　　例1：直接创建实例对象

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

    public static Singleton01 instance = new Singleton01();

    private Singleton01 (){}

}

　　例2：枚举对象

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

    INSTANCE;

}

　　例3：静态代码块形式

public class Singleton03 {

    public static final Singleton03 INSTANCE;

    private String info;

    static {
        try {
            Properties properties = new Properties();
            properties.load(Singleton03.class.getClassLoader().getResourceAsStream("singleton.properties"));

            INSTANCE = new Singleton03(properties.getProperty("info"));
        }catch (IOException e) {
            throw new RuntimeException(e);
        }

    }

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

    public String getInfo() {
        return info;
    }

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

懒汉式

　　例1：静态变量保存这个实例

/**
 * 懒汉式：
 *   延迟创建这个实例对象
 *
 * （1）构造器私有化
 * （2）用一个静态变量保存这个实例
 * （3）提供一个静态方法，获取这个实例对象
 */
public class Singleton04 {
    private static Singleton04 instance;

    private Singleton04(){}

    public static Singleton04 getInstance() {
        if(instance == null) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            instance = new Singleton04();
        }
        return instance;
    }
}

　　例2：静态方法线程安全

/**
 * 懒汉式：
 *   延迟创建这个实例对象
 *
 * （1）构造器私有化
 * （2）用一个静态变量保存这个实例
 * （3）提供一个静态方法，获取这个实例对象
 */
public class Singleton05 {
    private static Singleton05 instance;

    private Singleton05(){}

    public static Singleton05 getInstance() {
        synchronized (Singleton05.class) {
            if(instance == null) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                instance = new Singleton05();
            }
        }

        return instance;
    }
}

　　例3：内部类初始化

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

    private Singleton06(){}

    private static class Inner{
        private static Singleton06 instance = new Singleton06();
    }

    public Singleton06 getInstance(){
        return Inner.instance;
    }
}