Java中 单例模式 的实现

设计模式是语言无关的

一个类在内存中只有一个实例。无论哪个线程过来访问，取到的都是同一个对象。 可以在容器启动的时候new 一次，放到内存当中，私有化构造器，提供访问new出来对象的方式即可。

单例模式的实现方式

主要从线程的安全性、性能和是否懒加载 来考虑

饿汉式

public class HungerySingleton {
    //加载的时候就产生的实例对象
    private static HungerySingleton instance=new HungerySingleton();
    
    private HungerySingleton(){
    }

    //返回实例对象
   public static HungerySingleton getInstance(){
        return instance;
   }
}

线程安全性：类加载的时候已经被实例化，只有这一次，线程安全的
懒加载 ： 没有延迟加载，对象一致在内存中，影响性能

懒汉式

public class LazySingleton {
    private static LazySingleton instance=null;
    private LazySingleton(){
    }
    public static LazySingleton getInstance(){
        if(null==instance)
            instance=new LazySingleton();
        return instance;
    }
}

线程安全：并发情况下不能保证对象的唯一性
采用懒加载方式，性能较高

要求保证性能的情况下，使用懒汉式+同步方法解决

双重锁检查（Double-Check-Locking）

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

优点：性能比较好
问题：因为指令重排一起空指针异常
解决方式: 声明时加上volatile
private volatile static DCL instance=null;

静态内部类

使用最多的单例实现。声明类的时候，成员变量中不声明实例变量，而放到内部静态类中

public class Demo{
    private Demo(){
    }
    private static class Bulider{
        private static Demo instance=new Demo();
    }
    //懒加载
    //synchronized
    public static Demo getInstance(){
        return Builder.instance;
    }
}

枚举

public class EnumSingletonDemo {
    private EnumSingletonDemo(){
    }
    //延迟加载
    private enum EnumBuilder{
        INSTANCE;
        private static  EnumSingletonDemo instance=null;

        private EnumSingletonDemo getInstance(){
            instance=new EnumSingletonDemo();
            return instance;
        }
    }
    public static EnumSingletonDemo getInstance(){
        return EnumBuilder.INSTANCE.instance;
    }

}