java面试题之手写单例设计模式

• 单例模式特点：
• 饿汉式
• • 方式一
  • 方式二枚举类方式
  • 方式三静态代码块方式
• 懒汉式
• • 方式一
  • 方式二线程安全版
  • 方式三静态内部类

1、单例类只能有一个实例（构造器私有化）。
　　2、单例类必须自己创建自己的唯一实例（含有一个该类的静态变量来保存这个唯一的实例）。
　　3、单例类必须给所有其他对象提供这一实例

饿汉式：直接创建对象，不存在线程安全问题，不管你是否需要这个对象都会创建

public class Singleton1 {
  
    public static final Singleton1  INSTANCE=new Singleton1();
      // 私有构造
    private Singleton1(){

    }
}

最简洁

public enum Singleton2 {
    SINGLETON_2
}

public class Singleton3 {

    public static final Singleton3 INSTANCE;
    private Singleton3(){

    }

    static {
        INSTANCE=new Singleton3();
    }
}

延迟创建这个对象

构造器私有化
用一个静态变量保存这个唯一的实例
提供一个静态方法，获取这个实例对象

有线程安全问题

public class Singleton4 {
    private static Singleton4 instance;
    private Singleton4(){

    }
    public static Singleton4 getInstance(){
        if(instance==null){
            instance=new Singleton4();
        }
        return instance;
    }
}

假设有两个线程刚好第一个线程进入getInstance()并判断此时不为null，在还没new之前让出cpu执行权，此时第二个线程刚好进入，也为null，因此就创建了两个不一样的对象

public class Singleton5 {
    private static Singleton5 instance;
    private Singleton5(){

    }
    public static Singleton5 getInstance(){
        if(instance==null){
            synchronized (Singleton5.class){
                if(instance==null){
                    instance=new Singleton5();
                }
            }
        }
        
        return instance;
    }
}

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

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