单例模式写法

单例模式几种写法

懒汉式写法

public class LazySingleton {//懒汉式的单例

    //保证 lazySingleton 在所有线程中同步
    private static volatile LazySingleton lazySingleton = null;

    //private避免类在外部被实例化
    private LazySingleton() {
        if (lazySingleton!=null){
            throw new RuntimeException("防止反射破解");
        }
    }

    public static synchronized LazySingleton getInstance(){
        //getInstance 方法前加同步
        if (lazySingleton==null){
            lazySingleton = new LazySingleton();
        }
        return lazySingleton;
    }
}

双重检查

public class Singleton {

    private static volatile Singleton singleton;

    private Singleton() {}

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

饿汉式(静态常量)

public class HungrySingleton { //饿汉式单例
    
    private static HungrySingleton hungrySingleton = new HungrySingleton();
    
    //private避免类在外部被实例化
    private HungrySingleton(){
        if (hungrySingleton!=null){
            throw new RuntimeException("防止反射破解");
        }
    }
    
    public static HungrySingleton getInstance()
    {
        return hungrySingleton;
    }
}

饿汉式(静态代码块)

public class Singleton {
    
    private static Singleton instance;
    
    static {
        instance = new Singleton();
    }
    
    private Singleton(){
        
    }
    
    public static Singleton getInstance(){
        return instance;
    }
}

静态内部类(推荐用)

public class Singleton {

    private Singleton() {}

    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

枚举(最好的方式)

Java规范字规定，每个枚举类型及其定义的枚举变量在jvm中都是唯一的，因此在枚举类型的序列化和反序列化上，Java做了特殊的规定。在序列化的时候Java仅仅是将枚举对象的name属性输到结果中，反序列化的时候则是通过java.lang.Enum的valueOf()方法来根据名字查找枚举对象。也就是说，序列化的时候只将SINGLETON 这个名称输出，反序列化的时候再通过这个名称，查找对应的枚举类型，因此反序列化后的实例也会和之前被序列化的对象实例相同。

public class EnumSingleton {
	//需要实现单例的类
}

//枚举实现
public enum Singleton {
   SINGLETON;
   private EnumSingleton enumSingleton = null;
   private Singleton(){
       enumSingleton = new EnumSingleton();
   }
   public EnumSingleton getEnumSingleton(){
       return enumSingleton;
   }
}

//测试
public class Test {
    public static void main(String[] args) {
        EnumSingleton enumSingleton1 = Singleton.SINGLETON.getEnumSingleton();
        EnumSingleton enumSingleton2 = Singleton.SINGLETON.getEnumSingleton();
        System.out.println(enumSingleton1 == enumSingleton2);//打印结果 true
    }
}