五种单例模式实现

Posted zitai

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了五种单例模式实现相关的知识,希望对你有一定的参考价值。

核心作用:
保证一个类只有一个实例,并向外提供一个访问该实例的访问点。
 
常见场景:
  • 数据库连接池的设计一般也是单例模式
  • 在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;
    }
}
缺点:
不能延迟加载。
 
 
 

以上是关于五种单例模式实现的主要内容,如果未能解决你的问题,请参考以下文章

五种单例模式

快速理解Java中的五种单例模式

快速理解Java中的五种单例模式

设计模式总结(Java)

设计模式总结(Java)

五种单例模式----来自脚本之家