java静态内部类单例模式_单例模式--理解静态内部类实现线程安全的单例模式

最近也是在学习设计模式，资料：《设计模式之禅》，里面第一个就是单例模式，之前以为单例是一个非常简单的东西，其实里面有很多坑。

最简单的单例：

/**

* 简单饿汉式

* @author Administrator

*/

public class Singleton {

//单例实例变量

private static Singleton instance = new Singleton();

//私有化的构造方法，保证外部的类不能通过构造器来实例化

private Singleton() {

}

public static Singleton getInstance() {

return instance;

}

}略聪明点的单例：

/**

* 简单懒汉式

*/

public class Singleton {

private static Singleton instance = null;

//私有化的构造方法，保证外部的类不能通过构造器来实例化

private Singleton() {

}

//获取单例对象实例

public static Singleton getInstance() {

if (instance == null) {

instance = new Singleton();

}

System.out.println("我是同步法懒汉式单例！");

return instance;

}

}

很容易看出，上面这段代码在多线程的情况下是不安全的，当两个线程进入if (instance == null)时，两个线程都判断instance为空，接下来就会得到两个实例了。

接下来我们用加锁的方式来实现互斥，从而保证单例的实现：

/**

* 同步法懒汉式

*/

public class Singleton {

//单例实例变量

private static Singleton instance = null;

//私有化的构造方法，保证外部的类不能通过构造器来实例化

private Singleton() {

}

//获取单例对象实例

public static synchronized Singleton getInstance() {

if (instance == null) {

instance = new Singleton();

}

System.out.println("我是同步法懒汉式单例！");

return instance;

}

}加上synchronized后确实保证了线程安全，但是这样就是最好的方法吗？很显然它不是，因为这样一来每次调用getInstance()方法是都会被加锁，而我们只需要在第一次调用getInstance()的时候加锁就可以了。这显然影响了我们程序的性能。我们继续寻找更好的方法。

//双重锁定懒汉式

public class Singleton {

//单例实例变量

private static Singleton instance = null;

//私有化的构造方法，保证外部的类不能通过构造器来实例化

private Singleton() {

}

//获取单例对象实例

public static Singleton getInstance() {

if (instance == null) {

synchronized (Singleton.class) {

if (instance == null) {

instance = new Singleton();

}

}

}

System.out.println("我是双重锁定懒汉式单例！");

return instance;

}

}这次看起来既解决了线程安全问题，又不至于每次调用getInstance()都会加锁导致降低性能。看起来是一个完美的解决方案，事实上是这样的吗？

很遗憾，事实并非我们想的那么完美。java平台内存模型中有一个叫“无序写”(out-of-order writes)的机制。正是这个机制导致了双重检查加锁方法的失效。这个问题的关键在上面代码上的第5行：instance = new Singleton(); 这行其实做了两个事情：1、调用构造方法，创建了一个实例。2、把这个实例赋值给instance这个实例变量。可问题就是，这两步jvm是不保证顺序的。也就是说。可能在调用构造方法之前，instance已经被设置为非空了。下面我们一起来分析一下：

假设有两个线程A、B

1、线程A进入getInstance()方法。

2、因为此时instance为空，所以线程A进入synchronized块。

3、线程A执行 instance = new Singleton(); 把实例变量instance设置成了非空。(注意，是在调用构造方法之前。)

4、线程A退出，线程B进入。

5、线程B检查instance是否为空，此时不为空(第三步的时候被线程A设置成了非空)。线程B返回instance的引用。(问题出现了，这时instance的引用并不是Singleton的实例，因为没有调用构造方法。)

6、线程B退出，线程A进入。

7、线程A继续调用构造方法，完成instance的初始化，再返回。

如上所述，单例来到的终极版：

//内部类实现懒汉式

public class Singleton {

private static class SingletonHolder{

//单例变量

private static Singleton instance = new Singleton();

}

//私有化的构造方法，保证外部的类不能通过构造器来实例化。

private Singleton() {

}

//获取单例对象实例

public static Singleton getInstance() {

System.out.println("我是内部类单例！");

return SingletonHolder.instance;

}

} 懒汉式(避免上面的资源浪费)、线程安全、代码简单。因为java机制规定，内部类SingletonHolder只有在getInstance()方法第一次调用的时候才会被加载(实现了lazy)，而且其加载过程是线程安全的(实现线程安全)。内部类加载的时候实例化一次instance。   简单说一下上面提到的无序写，这是jvm的特性，比如声明两个变量，String a; String b; jvm可能先加载a也可能先加载b。同理，instance = new Singleton();可能在调用Singleton的构造函数之前就把instance置成了非空。这是很多人会有疑问，说还没有实例化出Singleton的一个对象，那么instance怎么就变成非空了呢？它的值现在是什么呢？想了解这个问题就要明白instance = new Singleton();这句话是怎么执行的，下面用一段伪代码向大家解释一下： [java]  mem = allocate();             //为Singleton对象分配内存。     instance = mem;               //注意现在instance是非空的，但是还没有被初始化。          ctorSingleton(instance);    //调用Singleton的构造函数，传递instance.    由此可见当一个线程执行到instance = mem; 时instance已为非空，如果此时另一个线程进入程序判断instance为非空，那么直接就跳转到return instance;而此时Singleton的构造方法还未调用instance，现在的值为allocate();返回的内存对象。所以第二个线程得到的不是Singleton的一个对象，而是一个内存对象。