设计模式-单例模式

单例模式

1）提供了对唯一实例的受控访问。
2）由于在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能。
3）允许可变数目的实例。

特点

1）单例类只能有一个实例。
2）单例类必须自己自己创建自己的唯一实例。
3）单例类必须给所有其他对象提供这一实例

此片文章部分实例为转载

饿汉模式

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

但是有一个问题——无论这个类是否被使用，都会创建一个instance对象。

懒汉模式

public class Singleton {    private static Singleton uniqueInstance = null;    private Singleton() {       // Exists only to defeat instantiation.    }    public static Singleton getInstance() {       if (uniqueInstance == null) {           uniqueInstance = new Singleton();       }       return uniqueInstance;    }    // Other methods...}

但是该方法线程并不安全，可能多线程间并发调用。
线程A希望使用SingletonClass，调用getInstance()方法。因为是第一次调用，A就发现instance是null的，于是它开始创建实例，就在这个时候，CPU发生时间片切换，线程B开始执行，它要使用SingletonClass，调用getInstance()方法，同样检测到instance是null——注意，这是在A检测完之后切换的，也就是说A并没有来得及创建对象——因此B开始创建。B创建完成后，切换到A继续执行，因为它已经检测完了，所以A不会再检测一遍，它会直接创建对象。这样，线程A和B各自拥有一个SingletonClass的对象——单例失败！

登记式单例类

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

getInstance()加上同步锁，一个线程必须等待另外一个线程创建完成后才能使用这个方法，这就保证了单例的唯一性。然而，简单的东西往往不够理想。这段代码毫无疑问存在性能的问题——synchronized修饰的同步块可是要比一般的代码段慢上几倍的！如果存在很多次getInstance()的调用，那性能问题就不得不考虑了！

优化

public class SingletonClass {   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() {   }}

首先判断instance是不是为null，如果为null，加锁初始化；如果不为null，直接返回instance。这就是double-checked locking设计实现单例模式。到此为止，一切都很完美。我们用一种很聪明的方式实现了单例模式。

出错

下面我们来考虑这么一种情况：线程A开始创建SingletonClass的实例，此时线程B调用了getInstance()方法，首先判断instance是否为null。按照我们上面所说的内存模型，A已经把instance指向了那块内存，只是还没有调用构造方法，因此B检测到instance不为null，于是直接把instance返回了——问题出现了，尽管instance不为null，但它并没有构造完成，就像一套房子已经给了你钥匙，但你并不能住进去，因为里面还没有收拾。此时，如果B在A将instance构造完成之前就是用了这个实例，程序就会出现错误了！

public class SingletonClass {   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指针临时变量的内存空间。写出这种代码基于以下思想，即synchronized会起到一个代码屏蔽的作用，同步块里面的代码和外部的代码没有联系。因此，在外部的同步块里面对临时变量sc进行操作并不影响instance，所以外部类在instance=sc;之前检测instance的时候，结果instance依然是null。
不过，这种想法完全是错误的！同步块的释放保证在此之前——也就是同步块里面——的操作必须完成，但是并不保证同步块之后的操作不能因编译器优化而调换到同步块结束之前进行。因此，编译器完全可以把instance=sc;这句移到内部同步块里面执行。这样，程序又是错误的了！

JAVA中的单例模式

说了这么多，难道单例没有办法在Java中实现吗？其实不然！
在JDK 5之后，Java使用了新的内存模型。volatile关键字有了明确的语义——在JDK1.5之前，volatile是个关键字，但是并没有明确的规定其用途——被volatile修饰的写变量不能和之前的读写代码调整，读变量不能和之后的读写代码调整！因此，只要我们简单的把instance加上volatile关键字就可以了。

public class SingletonClass {   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() {   }     } 

然而，这只是JDK1.5之后的Java的解决方案，那之前版本呢？其实，还有另外的一种解决方案，并不会受到Java版本的影响：
 

public class SingletonClass {       private static class SingletonClassInstance {     private static final SingletonClass instance = new SingletonClass();   }   public static SingletonClass getInstance() {     return SingletonClassInstance.instance;   }   private SingletonClass() {   }     } 

在这一版本的单例模式实现代码中，我们使用了Java的静态内部类。这一技术是被JVM明确说明了的，因此不存在任何二义性。在这段代码中，因为SingletonClass没有static的属性，因此并不会被初始化。直到调用getInstance()的时候，会首先加载SingletonClassInstance类，这个类有一个static的SingletonClass实例，因此需要调用SingletonClass的构造方法，然后getInstance()将把这个内部类的instance返回给使用者。由于这个instance是static的，因此并不会构造多次。
 
由于SingletonClassInstance是私有静态内部类，所以不会被其他类知道，同样，static语义也要求不会有多个实例存在。并且，JSL规范定义，类的构造必须是原子性的，非并发的，因此不需要加同步块。同样，由于这个构造是并发的，所以getInstance()也并不需要加同步。
 
至此，我们完整的了解了单例模式在Java语言中的时候，提出了两种解决方案。个人偏向于第二种，并且Effiective Java也推荐的这种方式。