五种单例模式实现

Posted 2021-03-14 zitai

核心作用：

保证一个类只有一个实例，并向外提供一个访问该实例的访问点。

 

常见场景：

• 数据库连接池的设计一般也是单例模式
• 在Servlet编程中，每个Servlet也是单例模式
• 在Spring中，默认创建的bean也是单例模式
• 。。。。。。

 

 

优点：

1、由于每个类只创建一个实例，大大减少了内存的开销。

2、单例模式提供全局访问点，可以实现共享资源访问。

 

常见的五种单例模式实现方法：

• 饿汉式（线程安全，效率高，不能延迟加载）
• 懒汉式（线程安全，效率不高，可以延迟加载）
• DCL懒汉式（线程安全，效率还行，可以延迟加载，由于关于JVM底层内部模型原因，即指令重排，偶尔会出现问题，不推荐使用）
• 静态内部类之饿汉式（线程安全，效率高，可以延迟加载）
• 枚举单例（线程安全，效率高，不可以延迟加载，用于解决上面4个方法的反射问题）

 

 

饿汉式：

public class Singleton01 {
//    私有化构造器
    private Singleton01(){};
//    类加载的时候就创建实例出来
    public static final Singleton01 singleton = new Singleton01();
//      全局访问点没synchronized关键字，所以效率高
    public static Singleton01 getInstance(){
        return singleton;
    }
}

缺点：

如果这个类的实例一直没有被使用，那么也是浪费内存资源。解决这个问题就出现了懒汉式，使用的时候再创建。

 

懒汉式：

public class Singleton02 {
    private Singleton02(){};
//   先把对象引用设为null
    public static  Singleton02 singleton = null;
//  使用了synchronized关键字，所以效率不高
    public static synchronized Singleton02 getInstance(){
        if(singleton == null){
            singleton = new Singleton02();
        }
        return singleton;
    }
}

缺点：

效率不高。解决这个问题出现了DCL懒汉式，将synchronized锁的代码更加精确

 

DCL懒汉式：

public class Singleton03 {
    private Singleton03(){};

    public  static  Singleton03 singleton = null;

    public static synchronized Singleton03 getInstance(){
        if(singleton == null){
//            锁住更加精确的代码，尽量让效率提高
            synchronized (Singleton03.class){
                if(singleton == null){
                    singleton = new Singleton03();
                }
            }
        }
        return singleton;
    }
}

缺点：

由于JVM底层内部模型，指令重排，出现问题。具体体现：

由于singleton = new Singleton03()不是原子操作，理论具体操作为：

memory = allocate(); //1：分配对象的内存空间 ctorInstance(memory); //2：初始化对象 instance = memory; //3：设置instance指向刚分配的内存地址

由于指令重排可能变成：

memory = allocate(); //1：分配对象的内存空间 instance = memory; //3：设置instance指向刚分配的内存地址，此时对象还没被初始化 ctorInstance(memory); //2：初始化对象

当进程a执行第二个指令的时候，又有一个进程b访问getInstance方法，这时候singleton不为空，但由于进程a还没初始化，这个进程b就把没初始化的对象返回出去，出现了问题了。

解决方法：

public static Singleton03 singleton = null;改为public volatile static Singleton03 singleton = null;

 

静态内部类之饿汉式：

public class Singleton04 {
    private Singleton04(){};
    private static class InnerClass{
        private static final Singleton04 singleton = new Singleton04();
    }
    public static Singleton04 getInstance(){
        return InnerClass.singleton;
    }
}

缺点：

反射可以获取类的class对象，修改构造函数的可见性，强制创建一个的对象。

 

 

枚举单例：

优点：是为了解决上面四种方法的一个缺点，就是反射问题。

可以产生问题的代码：

Constructor<Singleton04> constructor = Singleton04.class.getConstructor();
constructor.setAccessible(true);
final Singleton04 singleton04 = constructor.newInstance();

解决方法：

通过查看Constructor的源码：

@CallerSensitive
@ForceInline // to ensure Reflection.getCallerClass optimization
public T newInstance(Object ... initargs)
    throws InstantiationException, IllegalAccessException,
           IllegalArgumentException, InvocationTargetException
{
    if (!override) {
        Class<?> caller = Reflection.getCallerClass();
        checkAccess(caller, clazz, clazz, modifiers);
    }
    if ((clazz.getModifiers() & Modifier.ENUM) != 0)
        throw new IllegalArgumentException("Cannot reflectively create enum objects");
    ConstructorAccessor ca = constructorAccessor;   // read volatile
    if (ca == null) {
        ca = acquireConstructorAccessor();
    }
    @SuppressWarnings("unchecked")
    T inst = (T) ca.newInstance(initargs);
    return inst;
}

可以看到当类的为枚举类型，即使改了可见性，当执行newInstance也会抛出IllegalArgumentException错误出来，不能实例化一个对象。

所以将单例模式的类设置为枚举类，代码为：

public enum Singleton05 {
    SINGLETON;

    public Singleton05 getSingleton(){
        return SINGLETON;
    }
}

缺点：

不能延迟加载。