一、懒汉式,线程不安全

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

具有Lazy-Loading,但是多线程下不安全

二、懒汉式,线程安全

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

三、饿汉式

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

基于classloder机制避免了多线程的同步问题,让instance实例在类装载时就实例化
缺点:
1. 但是这样子没有Lazy-Loading的效果,如果Instance的初始化很大,效率会很低
2. 如果instance的创建需要依赖参数或者是配置文件,将无法使用

四、静态内部类

public class Singleton {   
    private static class SingletonHolder {   
    private static final Singleton INSTANCE = new Singleton();   
    }   
    private Singleton (){}   
    public static final Singleton getInstance() {   
    return SingletonHolder.INSTANCE;   
    }   
}  

这种方式同样利用了classloder的机制来保证初始化instance时只有一个线程,但是这种也是有Lazy-Loading的效果的,因为SingletonHolder类没有被主动使用,只有显示通过调用getInstance方法时,才会显示装载SingletonHolder类,从而实例化instance

五、双重检查

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

为什么要加volatile?

我们来考虑一下,不加volatile的情况:

singleton = new Singleton();

这并非是一个原子操作,事实上在 JVM 中这句话大概做了下面 3 件事情。

  1. 给 instance 分配内存
  2. 调用 Singleton 的构造函数来初始化成员变量
  3. 将instance对象指向分配的内存空间(执行完这步 instance 就为非 null 了)

但是在 JVM 的即时编译器中存在指令重排序的优化。也就是说上面的第二步和第三步的顺序是不能保证的,最终的执行顺序可能是 1-2-3 也可能是 1-3-2,(也就是不存在happen-before);
如果是后者,则在 3 执行完毕、2 未执行之前,被线程二抢占了,这时 instance 已经是非 null 了(但却没有初始化),所以线程二会直接返回 instance,然后使用,然后顺理成章地报错。

解决:使用volatile

volatile可以禁止指令重排序优化。也就是说,在 volatile 变量的赋值操作后面会有一个内存屏障(生成的汇编代码上),读操作不会被重排序到内存屏障之前。
加了volatile之后,此时存在volatile的happen-before原则:

volatile写操作一定先行于volatile的读操作

比如上面的例子,当singleton加上了volatile之后,new Singleton()是一个写操作,所以执行完 1-2-3 之后或者 1-3-2 之后,不存在执行到 1-3 然后取到值的情况,这样就是一个安全的单例了

五、最简单,最好的单例:枚举

public enum Singleton {   
    INSTANCE;   
    public void whateverMethod() {   
    }   
}  

这种方式的好处是:
1. 利用的枚举的特性实现单例
2. 由JVM保证线程安全
3. 序列化和反射攻击已经被枚举解决

扩展

1、如何防止单例被反射破坏?
思路:设置一个flag,让它创建第二个实例时,抛出异常
http://blog.csdn.net/u013256816/article/details/50525335

2、序列化破坏反射如何避免?
http://www.importnew.com/18030.html

发布评论

分享到:

IT虾米网

微信公众号号:IT虾米 (左侧二维码扫一扫)欢迎添加!

使用Lock和Condition实现哲学家算法问题详解
你是第一个吃螃蟹的人
发表评论

◎欢迎参与讨论,请在这里发表您的看法、交流您的观点。