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;
    }
}