private static final SingletonClass instance = new SingletonClass();
public static SingletonClass getInstance() {
return instance;
}
private SingletonClass() {
}
}
private static SingletonClass instance = null;
public static SingletonClass getInstance() {
if(instance == null) {
instance = new SingletonClass();
}
return instance;
}
private SingletonClass() {
}
}
这样。线程A和B各自拥有一个SingletonClass的对象——单例失败。
private static SingletonClass instance = null;
public synchronized static SingletonClass getInstance() {
if(instance == null) {
instance = new SingletonClass();
}
return instance;
}
private SingletonClass() {
}
}
这段代码毫无疑问存在性能的问题——synchronized修饰的同步块但是要比一般的代码段慢上几倍的!假设存在非常多次getInstance()的调用。那性能问题就不得不考虑了。
原因就是检測null的操作和创建对象的操作分离了。
假设这两个操作可以原子地进行,那么单例就已经保证了。
于是,我们開始改动代码:
private static SingletonClass instance = null;
public static SingletonClass getInstance() {
synchronized (SingletonClass.class) {
if(instance == null) {
instance = new SingletonClass();
}
}
return instance;
}
private SingletonClass() {
}
}
可是这种改动起不到不论什么作用:由于每次调用getInstance()的时候必定要同步,性能问题还是存在。
假设……假设我们事先推断一下是不是为null再去同步呢?
private static SingletonClass instance = null;
public static SingletonClass getInstance() {
if (instance == null) {
synchronized (SingletonClass.class) {
if (instance == null) {
instance = new SingletonClass();
}
}
}
return instance;
}
private SingletonClass() {
}
}
我们用一种非常聪明的方式实现了单例模式。
编译原理里面有一个非常重要的内容是编译器优化。
所谓编译器优化是指,在不改变原来语义的情况下。通过调整语句顺序。来让程序执行的更快。
这个过程成为reorder。
private static SingletonClass instance = null;
public static SingletonClass getInstance() {
if (instance == null) {
SingletonClass sc;
synchronized (SingletonClass.class) {
sc = instance;
if (sc == null) {
synchronized (SingletonClass.class) {
if(sc == null) {
sc = new SingletonClass();
}
}
instance = sc;
}
}
}
return instance;
}
private SingletonClass() {
}
}
同步块的释放保证在此之前——也就是同步块里面——的操作必须完毕。可是并不保证同步块之后的操作不能因编译器优化而调换到同步块结束之前进行。因此,编译器全然能够把instance=sc;这句移到内部同步块里面运行。这样。程序又是错误的了!
volatilekeyword有了明白的语义——在JDK1.5之前,volatile是个keyword。可是并没有明白的规定其用途——被volatile修饰的写变量不能和之前的读写代码调整,读变量不能和之后的读写代码调整!
因此,仅仅要我们简单的把instance加上volatilekeyword就能够了。
private volatile static SingletonClass instance = null;
public static SingletonClass getInstance() {
if (instance == null) {
synchronized (SingletonClass.class) {
if(instance == null) {
instance = new SingletonClass();
}
}
}
return instance;
}
private SingletonClass() {
}
}
private static class SingletonClassInstance {
private static final SingletonClass instance = new SingletonClass();
}
public static SingletonClass getInstance() {
return SingletonClassInstance.instance;
}
private SingletonClass() {
}
}
直到调用getInstance()的时候,会首先载入SingletonClassInstance类。这个类有一个static的SingletonClass实例。因此须要调用SingletonClass的构造方法。然后getInstance()将把这个内部类的instance返回给使用者。
由于这个instance是static的,因此并不会构造多次。
而且,JSL规范定义。类的构造必须是原子性的,非并发的。因此不须要加同步块。
相同,因为这个构造是并发的。所以getInstance()也并不须要加同步。