茴香豆的九种写法——论java单例写法

最新推荐文章于 2024-04-12 17:42:27 发布

weixin_33826268

最新推荐文章于 2024-04-12 17:42:27 发布

阅读量245

点赞数

文章标签： java python

原文链接：https://my.oschina.net/u/2457218/blog/3044301

版权

2019独角兽企业重金招聘Python工程师标准>>>

懒汉式

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

}

饿汉式

public class HungarySingleton {
    private static HungarySingleton singleton = new HungarySingleton();

    private HungarySingleton(){}

    public static HungarySingleton getInstance(){
        return singleton;
    }
}

双重检查锁

public class DoubleCheckSingleton {

    private static volatile DoubleCheckSingleton singleton;

    private DoubleCheckSingleton() {}

    public static DoubleCheckSingleton getSingleton() {
        if (singleton != null) {
            return singleton;
        } else {
            synchronized (DoubleCheckSingleton.class) {
                if (singleton == null) {
                    singleton = new DoubleCheckSingleton();
                }
                return singleton;
            }
        }
    }
}

使用静态内部类

public class StaticInnerClassSingleton {

    private StaticInnerClassSingleton(){}

    private static class StaticInnerClass{
        private static StaticInnerClassSingleton singleton = new StaticInnerClassSingleton();
    }

    public StaticInnerClassSingleton getInstance(){
        return StaticInnerClass.singleton;
    }
}

使用枚举

public class EnumSingleton {

    private enum  Singleton{
        INSTANCE;
        EnumSingleton enumSingleton;
        Singleton(){
            synchronized (this){
                enumSingleton = new EnumSingleton();
            }
        }
    }
    public EnumSingleton getInstance(){
        return Singleton.INSTANCE.enumSingleton;
    }

}

各种写法的比较

懒汉式：提供了延迟初始化，不使用的时候不会初始化，但是效率不高，每次进来都要加锁，竞争激烈的情况下效率下降严重。
饿汉式：借用了JVM classloader机制，这种方式类加载较慢，但在使用的时候速度会比较快。
枚举：《effective java》中提的方式，简洁，并且无偿提供了序列化机制，绝对的防止了多次实例化，即时是面对各种序列化或反序列化攻击，推荐使用。
静态内部类方式：使用静态内部类的方式，可以借用JVM的classload机制，保证单例，在classloader内部实际上也是通过加锁的方式实现的。
双重检查锁：这个在《java并发编程的艺术》中有提及，如果DoubleCheckSingleton没有被volatile修饰，有可能会产生问题，产生问题的根源在于 singleton = new DoubleCheckSingleton(); 这一行。这个可以理解为如下三行伪代码

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

在上面3行伪代码2和3之间，可能会被重排序。重排序之后的顺序可能变为 1,3,2。在JVM规范中允许在单线程内，不会改变单线程程序执行结果的重排序。这个重排序在没有改变单线程执行结果的前提下可以提高程序的执行效率。但是这种写法在多线程中会出现问题，if (singleton == null) 进行了判断，但是如果线程T1，限制性了3，这时候instance不等于null，T2进来之后判断singleton！=null，开始拿到这个对象直接使用，但是这个singleton对象还没有被初始化（ctorInstance）。那就是导致T2使用这个对象的时候出错。以上就是如果singleton没有加volatile导致的结果。由于加了volatile，会禁止指令重排序，就不会出现上面的问题。所以这种写法是安全的。

转载于:https://my.oschina.net/u/2457218/blog/3044301