单例模式是设计模式中使用最普遍的设计模式之一。它是一种对对象创建模式，主要用于产生一个对象的具体唯一实例，它可以确保系统中一个类只产生一个实例。在Java语言中，这样的行为能带来两大好处:
1. 对于频繁使用的对象，可以节省创建对象所花费的时间，这对于那些重量级对象而言，是非常可观的一笔系统开销。
2. 由于new操作的次数减少，因而对系统的内存使用频率也会降低，这将减轻GC压力，缩短GC停顿时间。
因此对于系统的关键组件和被频繁使用的对象，使用单例模式便可以有效地改善系统的性能。下面简单实现了一个单例模式：
public class Singleton {
static{
System.out.println("Singleton is init!");
}
private Singleton(){
//创建单例的过程可能会比较慢
System.out.println("Singleton is create!");
}
private static Singleton instance = new Singleton();
public static Singleton getInstance(){
return instance;
}
}
主要代码中的重点标注部分，首先单例类必须要有一个private访问级别的构造函数，只有这样，才能确保单例不会在系统中的其他代码内被实例化，这点是相当重要的;其次，instance成员变量和getInstance()方法必须是static的。
这种单例的实现方式非常简单，而且十分可靠。它唯一的不足仅是对instance实例做延迟加载。例如单例的创建过程很慢，而由于instance成员变量是static定义的，因此在JVM加载单例类时，单例对象就会被建立，如果此时，这个单例类在系统中还扮演其他角色，那么在任何使用这个单例类的地方都会初始化这个单例变量，而不管是否会被用到。比如单例类作为String工厂，用于创建一些字符串（该类即用于创建单例Singleton,又用于创建字符串对象）
public class Singleton {
static{
System.out.println("Singleton is init!");
}
private Singleton(){
//创建单例的过程可能会比较慢
System.out.println("Singleton is create!");
}
private static Singleton instance = new Singleton();
public static Singleton getInstance(){
return instance;
}
public static void createString(){
System.out.println("createString in Singleton!");
}
当使用Singleton.createString()执行任务时，程序输出：
singleton is init!
singleton is create!
createString in Singleton!
从上面的输出结果可以看到，虽然此时并没有使用单例类，但它还是被创建了出来，这也许是开发人员所不愿意看到的。为了解决这个问题，并以此提高系统在相关函数调用时的反应速度，就需要引入延迟加载机制。
public class LazySingleton{
private LazySingleton(){
//创建单例的过程可能会比较慢
System.out.println("LazySingleton is create");
}
private static LazySingleton instance = null;
public static synchronized LazySingleton getInstance(){
if(instance == null)
instance = new LazySingleton();
return instance;
}
}
从上面的另一种延迟加载的单例写法可以看出，对于静态成员变量instance 初始值赋予null,确保系统启动时没有额外的负载。在getInstance()方法中，判断当前单例是否已经存在，若存在则返回，不存在则再建立单例。这里尤其还要注意，getInstance()方法必须是同步的，否则在多线程环境下，当线程1正新建单例时，完成赋值操作前，线程2可能判断instance为null,故线程2也将启动新建单例的程序，而导致多个实例被创建，故同步关键字是必须的。
使用上例中的单例实现，虽然实现了延迟加载的功能，但和第一种方法相比，他引入了同步关键字，因此在多线程环境中，它的时耗要远远大于第一种单例模式。让我们来测试一下。
@Override
public void main(){
for(int i = 0;i<100000;i++){
Singleton.getInstance();
//LazySingleton.getInstance();
System.out.println("spend time:"+(System.currentTimeMillis()-begintime))；
}
}
开启5个线程同事完成以上代码的运行，使用第1种类型的单例耗时0ms,而使用LazySingleton却相对耗时约390ms。性能至少相差2个数量级。
注意：在不同计算机上其测试结果很可能与以上测试结果不同。我们大可不必关心测试数据的绝对值，只要观察用于比较的目标代码间的相对耗时即可。
为了使用延迟加载引入同步关键字反而降低了系统性能，是不是有点得不偿失呢？为了解决这个问题，还需要对其进行改进：
public class StaticSingleton{
private StaticSingleton(){
System.out.println("StaticSingleton is create!")；
}
private static class SingletonHolder{
private static StaticSingleton instance = new StaticSingleton();
}
public static StaticSingleton getInstance(){
return SingletonHolder.instance;
}
}
在这个实现中，单例模式使用内部类来维护单例的实例，当StaticSingleton被加载时，其内部类并不会初始化，故可以确保当StaticSingleton类被载入JVM时，不会初始化单例类，而当getInstance()方法被调用时，才会加载SingletonHolder，从而初始化instance。同时，由于实例的建立是在类加载时完成，故对多线程天生友好，getInstance()方法也不需要使用同步关键字。因此，这种实现同时兼备以上两种实现的优点。
通常情况下，用以上方式实现的单例已经可以确保在系统中只存在唯一实例了。但仍然有例外情况，可能导致系统生成多个实例，比如，在代码中，通过反射机制，强行调用单例类的私有构造函数，生成多个单例。考虑到情况的特殊性，因此不准备再细说。下面主要说说还有些合法的方法，也可能导致系统出现多个单例类的实例。
public class Singleton implements java.io.Serializable{
static{
System.out.println("Singleton is init!");
}
private Singleton(){
//创建单例的过程可能会比较慢
System.out.println("Singleton is create!");
}
private static Singleton instance = new Singleton();
public static Singleton getInstance(){
return instance;
}
public static void createString(){
System.out.println("createString in Singleton!");
}
//阻止生成新的实例，总是返回当前对象。
private Object readResolve(){
return instance;
}
测试如下:
@Test
public void test throws Exception{
Singleton s1 = null;
Singleton s = Singleton.getInstance();
//先将实例串行化到文件
FileOutputStream fos = new FileOutputStream("serSingleton.txt");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(s);
oos.flush();
oos.close();
//从文件读出原有的单例类
FileInputStream fis = new FileInputStream("serSingleton.txt");
ObjectInputStream ois = new ObjectInputStream(fis);
s1 = (Singleton) ois.readObject();
Assert.assertEquals(s1,s);
}
使用上述测试代码测试单例的串行化和反串行化，当去掉Singleton代码中readResolve方法后，测试代码会抛出异常警告，说明测试代码中的s和s1指向不同的实例，在反序列化后，生成了多个对象实例。而加上readResolve()方法后，程序正常退出。说明，即便经过了反序列化，仍然保持了单例的特征。事实上，在实现了私有的readResolve()方法后，readResolve()已经形同虚设，它直接使用readResolve()替换了原本的返回值，从而在形式上构造了单例。
注意：序列化和反序列化可能会破坏单例，一般来说，对单例进行序列化和反序列化的场景并不多见，但如果存在，就要多加注意，小心使用啦！
