彻底理解单例模式

一、单例（Singleton）模式
　　单例模式的要点有三个：一是某个类只能有一个实例，二是它必需自行创建这个实例，三是它必须向整个系统自行提供这个实例．

二、典型单例类
下面是一个它的实现：

/*
 * 典型单例类,不能被继承
 */
public class Singleton {
    /* 
     * Singleton 类自己将自己实例化
     * 此该类被加载时,静态变量 instance 会通过调用私有构造函数被实例化
     */
    private static final Singleton instance = new Singleton();

    /*
     * 私有构造函数防止此类被外界调用而产生多个实例
     * 由于构造函数私有的类，所以不能被继承
     */
    private Singleton() {}

    public static Singleton getInstance() {
        return instance;
    }
}

三、延迟单例类：
与典型单例类不同的是，延迟单例类只有在第一次引用时才被实例化．

/*
 * 延迟单例类,不能被继承
 */
public class Singleton {
    /* 
     * Singleton 类自己将自己实例化
     * 此该类被加载时,静态变量 instance 会通过调用私有构造函数被实例化
     */
    private static Singleton instance = null;

    /*
     * 私有构造函数防止此类被外界调用而产生多个实例
     */
    private Singleton() {}

    /*
     * synchronized 同步化以处理多线程环境
     */
    public static synchronized Singleton getInstance() {
        if (instance == null)
            instance = new Singleton();
        return instance;
    }
}

四、容器单例类
容器单例类是针对上面两种单例类不能被继承的特点而设计的．下面是它的一个实现：

import java.util.HashMap;

public class Singleton {
	// 容器用来存放对应关系
       private static HashMap sinRegistry = new HashMap();

       private static Singleton s = new Singleton();

       // 受保护的构造函数
       protected Singleton() {}

       public static Singleton getInstance(String name) {
              if(name == null)
                     name = "Singleton";
              if(sinRegistry.get(name) == null) {
                     try {
                            sinRegistry.put(name , Class.forName(name).newInstance());
                     } catch(Exception e) {
                            e.printStackTrace();
                     }
              }
              return (Singleton)(sinRegistry.get(name));
       }
}

public class SingletonChild1 extends Singleton {
       public SingletonChild1() {}

       public static SingletonChild1 getInstance() {
              return (SingletonChild1) Singleton.getInstance("SingletonChild1");  
       }
}

五、各个单例类的比较：
　　单从资源利用角度来讲, 典型单例类较好; 从速度和反映时间来说延迟单例类较好.但是, 延迟单例类在实例化时, 必须处理好在多线程同时首次引用此类时的访问限制问题.特别是单例类在资源控制器在实例化时必然涉及资源初始化, 而资源初始化很有可能耗费时间, 这意味着出现多线程同时引用此类的几率变得较大

六、单例模式邪恶论：
看这题目也许有点夸张，不过这对初学者是一个很好的警告。单例模式在 java 中的使用存在很多陷阱和假象，这使得没有意识到单例模式使用局限性的你在系统中布下了隐患……
其实这个问题早在 2001 年的时候就有人在网上系统的提出来过，我在这里只是老生常谈了。但是对于大多的初学者来说，可能这样的观点在还很陌生。下面我就一一列举出单例模式在 java 中存在的陷阱。

多个虚拟机
当系统中的单例类被拷贝运行在多个虚拟机下的时候，在每一个虚拟机下都可以创建一个实例对象。在使用了EJB、JINI、RMI 技术的分布式系统中，由于中间件屏蔽掉了分布式系统在物理上的差异，所以对你来说，想知道具体哪个虚拟机下运行着哪个单例对象是很困难的。
因此，在使用以上分布技术的系统中，应该避免使用存在状态的单例模式，因为一个有状态的单例类，在不同虚拟机上，各个单例对象保存的状态很可能是不一样的，问题也就随之产生。而且在 EJB 中不要使用单例模式来控制访问资源，因为这是由 EJB 容器来负责的。在其它的分布式系统中，当每一个虚拟机中的资源是不同的时候，可以考虑使用单例模式来进行管理。

多个类加载器
当存在多个类加载器加载类的时候，即使它们加载的是相同包名，相同类名甚至每个字节都完全相同的类，也会被区别对待的。因为不同的类加载器会使用不同的命名空间（namespace）来区分同一个类。因此，单例类在多加载器的环境下会产生多个单例对象。也许你认为出现多个类加载器的情况并不是很多。其实多个类加载器存在的情况并不少见。在很多 J2EE 服务器上允许存在多个 servlet 引擎，而每个引擎是采用不同的类加载器的；浏览器中 applet 小程序通过网络加载类的时候，由于安全因素，采用的是特殊的类加载器，等等。这种情况下，由状态的单例模式也会给系统带来隐患。因此除非系统由协调机制，在一般情况下不要使用存在状态的单例模式。

错误的同步处理
在使用上面介绍的延迟单例模式时，同步处理的恰当与否也是至关重要的。不然可能会达不到得到单个对象的效果，还可能引发死锁等错误。因此在使用延迟单例模式时一定要对同步有所了解。不过使用典型单例模式就可以避免这个问题。

子类破坏了对象控制
在上一节介绍最后一种扩展性较好的单例模式实现方式的时候，就提到，由于类构造函数变得不再私有，就有可能失去对对象的控制。这种情况只能通过良好的文档来规范。

串行化（可序列化）
为了使一个单例类变成可串行化的，仅仅在声明中添加“implements Serializable”是不够的。因为一个串行化的对象在每次返串行化的时候，都会创建一个新的对象，而不仅仅是一个对原有对象的引用。为了防止这种情况，可以在单例类中加入 readResolve 方法。关于这个方法的具体情况请参考《Effective Java》一书第 57 条建议。其实对象的串行化并不仅局限于上述方式，还存在基于 XML 格式的对象串行化方式。这种方式也存在上述的问题，所以在使用的时候要格外小心。
正确的做法如下：

public final class Singleton implements Serializable {
	private static final long serialVersionUID = 1L;

	private Singleton() {}

	private static final Singleton instance = new Singleton();

	public static Singleton getInstance() {
		return instance;
	}

	private Object readResolve() throws ObjectStreamException {
		return instance;
	}
}

因为 JDK 在反序列化时，会调用私有非静态函数 readResolve（当有这个函数的时候），通过这个函数得到反序列化的对象，所以我们在这个函数中返回了唯一对象 instance，这样我们的单例终于得到保证了。
计数器实例：

import java.io.Serializable;
import java.io.ObjectStreamException;

public class Singleton implements Serializable {
        private static final long serialVersionUID = 1L; 

        private static Singleton instance; 

        private Integer counter = new Integer(0); 

        private Singleton() { 
                counter = 0; 
        }

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

        public synchronized int getNext() {
                return ++counter;
        }
	/* 反序列保证
	private Object readResolve() throws ObjectStreamException {
		return instance;
	}*/
}

import java.io.IOException;
import java.io.FileNotFoundException;

import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class Test {
        public static void main(String [] args) throws FileNotFoundException, IOException, ClassNotFoundException{ 
                Singleton singleton = Singleton.getInstance();    // 第一个对象 
                System.out.println(singleton.getNext());          // 打印 1 

                ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.obj"));
                oos.writeObject(singleton);                       // 将该对象写在 object.obj 文件中

                ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.obj")); 
                Singleton singleton2 = (Singleton)ois.readObject(); // 再读出来 

                System.out.println(singleton.getNext());       // 打印 2
		System.out.println(singleton.getNext());       // 打印 3
                System.out.println(singleton2.getNext());      // 打印 3 or 2 取决于是否实现了 readResolve() 方法
                System.out.println(singleton2 == singleton);   // 打印 true or false 取决于是否实现了 readResolve() 方法
        }
}

在 JDK 中，可以利用 JDK 的 bin 目录下的 serialver.exe 工具产生这个 serialVersionUID，对于 Test.class，执行命令：cmd> serialver Test。