常用设计模式----单例模式

package org.design.patterns;
/**
 * 单例模式（Singleton Pattern）：确保一个类只有一个实例，并提供一个全局（static）访问点。
 */

//延迟实例化的实现方法(不能用于多线程情况)
//如果不考虑多线程的情况，就选用该方法实现单例模式。
public class Singleton {
 private static Singleton uniqueInstance;

 private Singleton() {
 }

 public static Singleton getInstance() {
  if (uniqueInstance == null) {
   uniqueInstance = new Singleton();
  }
  return uniqueInstance;
 }
}

// ------------------------------------------------------
//急切实例化的实现方法（可用于多线程情况）
//JVM在加载该类的时候就马上创建了一个实例化对象
//如果对象不是太大，初始化和运行不是很消耗资源，并且有多线程的考虑时，可以用这种实现方式。
class Singleton2 {
 private static Singleton2 uniqueInstance = new Singleton2();

 private Singleton2() {
 }

 public static Singleton2 getInstance() {
  return uniqueInstance;
 }
}

//在getInstance方法上加入synchronized关键字，用于多线程情况
//这种方式虽然也能够解决多线程的问题，但是由于每一次调用getInstance方法时，
//都要做同步处理 (synchronized)，而实际上，只有当uniqueInstance为空时才需要同步，
//这样就大大影响了方法的执行效率，不推荐使用。
class Singleton3 {
 private static Singleton3 uniqueInstance;

 private Singleton3() {
 }

 public static synchronized Singleton3 getInstance() {
  if (uniqueInstance == null) {
   uniqueInstance = new Singleton3();
  }
  return uniqueInstance;
 }
}

//用"双重检查加锁"，只有uniqueInstance为空的情况下才加锁，在巧妙的提升了性能，用于多线程情况
//该方法是多线程情况下的首选。
class Singleton4 {
 //volatile关键字的确保了:写入 volatile 字段 happen-before 每个后续读取相同字段。
 //这样就保证了：当uniqueInstance变量被初始化成Singleton实例时，多个线程正确地处理uniqueInstance变量。
 private volatile static Singleton4 uniqueInstance;

 private Singleton4() {
 }

 public static synchronized Singleton4 getInstance() {
  if (uniqueInstance == null) {//第一次验空，如果为空才进入同步（事实上，只第一次的情况）
   synchronized (Singleton4.class) {
    if (uniqueInstance == null) {//第二次验空，空了就创建实例
     uniqueInstance = new Singleton4();
    }    
   }
  }
  return uniqueInstance;
 }
}

/*说明：
 * 单例模式在Java中存在的缺陷：
 * （1）多个虚拟机
 *   当系统中的单例类被copy运行在多个虚拟机下的时候，每一个虚拟机下都可以创建一个实例对象。
 *   在使用了EJB、JINI、RMI技术的分布式系统中，由于中间件屏蔽掉了分布式系统在物理上的差异，
 *   所以，想知道具体哪个虚拟机下运行着哪个单例对象是很困难的。
 *   因此，在使用了以上分布式技术的系统中，应该避免使用“存在状态”的单例模式，因为一个有状态的
 *   单例类，在不同虚拟机上，各个单例对象保存的状态可能是不一样的，问题就随之产生。
 * （2）多个类加载器
 *   当存在多个类加载器的时候，即使它们加载的是同包名，同类名甚至每个字节都完全相同的类，也会被区别对待。
 *   因为不同的类加载器会使用不同的命名空间（nameSpace）来区分一个类。因此，单例类在多个加载器的环境下
 *   会产生多个单例对象。
 * （3）串行化（可序列化）
 *   为了使一个单例类变成可串行化的，仅仅在声明中添加"implement serializable"是不够的。因为一个串行化对象
 *   在每次反串行化的时候都会创建一个新的对象，而不仅仅是一个队原对象的引用。
 *   基于xml格式的对象串行化的方式也存在上述问题，这些个时候，使用单例要当心。
 */