单例模式总结

单例模式是设计模式中最容易理解、最容易上手的设计模式，同时也是最容易出错的设计模式。它的实现写法有多种，但是并不都是正确的写法。
1、饿汉模式
饿汉，即迫切的、立马的，所以饿汉模式又称作立即加载，下面代码实现是它最普遍的写法。
public class SingletonObject {    
    private static final SingletonObject singletonObject = new SingletonObject();    
    private SingletonObject() {
    }    
    public static SingletonObject getInstance() {        
        return singletonObject;
    }
}
这种写法实现的单例对象会在类加载时创建，线程安全的。它的缺点很明显了，不能依赖参数或配置文件创建对象。
2、懒汉模式
懒汉，即慵懒的、不着急的，所以懒汉模式又称作延迟加载，下面代码即是它的实现。
public class SingletonObject {    
    private static SingletonObject singletonObject;    
    private SingletonObject() {
   }    
    public static SingletonObject getInstance() {        
        if (singletonObject == null) {
         singletonObject = new SingletonObject();
      }        
        return singletonObject;
    }
}
它可以根据参数或配置创建对象，这种写法很常见，但却是一种错误的写法，因为getInstance方法没有做同步控制，在多线程并发的情况下会出现线程不安全的情况，即创建多个实例对象。
3、懒汉模式的同步版
为了解决懒汉模式的非线程安全问题，实现了下面的这种写法。
public class SingletonObject {
    private static SingletonObject singletonObject;
    private SingletonObject() {
    }    
    synchronized public static SingletonObject getInstance() {
        if (singletonObject == null) {
            singletonObject = new SingletonObject();
        }
        return singletonObject;
    }
}
这种实现方式虽然解决了非线程安全问题，是线程安全的，但是效率较低，因为在多线程并发时，getInstance方法需要同步，同一时间只有一个线程可以访问执行，排队执行。
4、懒汉模式的双检查版
为了解决上面出现的效率低的问题，对代码进行了修改。
public class SingletonObject {
    private static SingletonObject singletonObject;
    private SingletonObject() {
    }
    public static SingletonObject getInstance() {
        if (singletonObject == null) {
            synchronized (SingletonObject.class) {
                if (singletonObject == null) {
                    singletonObject = new SingletonObject();
                }
            }
        }
        return singletonObject;
    }
}
双检查，即进行了两次singletonObject == null的判断，相对于上面的写法，效率上提升了一些。但是，它也是有问题的。问题的原因在于singletonObject = new SingletonObject()，这个不是原子操作，它的执行分以下先后三步：
一.给新创建的对象分配内存；
二.调用构造方法初始化成员变量；
三.将singletonObject指向新对象的内存空间。
上面的三步，执行到第三步时，singletonObject已经不是null了。然而JVM即时编译器存在指令重排序的优化，所以上面三步的执行顺序可能是一二三，也可能是一三二，当按后者顺序执行到三时，另一个线程执行到了if里面的非null判断，此时singletonObject已经不为null了，然而成员变量的值没有初始化，另一个线程直接拿着这个没有初始化完全的对象进行操作时，定会出错。
5、懒汉模式双检查版的加强版
为了解决上面未初始化完全的问题，使用volatile修改代码。
public class SingletonObject {
    private volatile static SingletonObject singletonObject;
    private SingletonObject() {
    }
    public static SingletonObject getInstance() {
        if (singletonObject == null) {
            synchronized (SingletonObject.class) {
                if (singletonObject == null) {
                    singletonObject = new SingletonObject();
                }
            }
        }
        return singletonObject;
    }
}
你可能认为使用volatile是为了实现多线程间的可见性，这里不是这个目的。这里的volatile是为了禁止指令的重排序，能保证happens-before relationship，所有的写都将先行发生于读。需要注意的是，在JDK 5之前的版本中使用volatile并不能完全阻止指令的重排序，原因是Java内存模型存在缺陷导致的。
6、静态内部类实现
静态内部类的方式是推荐的一种实现写法。
public class SingletonObject{
    private SingletonObject() {
    }
    private static class SingletonObjectHolder {
        private static SingletonObject singletonObject = new SingletonObject();
    }
    public static SingletonObject getInstance() {
        return SingletonObjectHolder.singletonObject;
    }
}
因为JVM本身的机制保证了这种写法是线程安全的，延迟加载，没有性能方面的缺陷。
7、静态代码块实现
public class SingletonObject implements Serializable {
    private static SingletonObject singletonObject;
    private SingletonObject() {
    }
    static {
        singletonObject = new SingletonObject();
    }
    public static SingletonObject getInstance() {
        return singletonObject;
    }
}
因为静态的代码块只能被执行一次，所以，这种写法是线程安全的。
8枚举实现
使用枚举实现单例，这种方式也是线程安全的，但是使用的比较少。
public enum Singleton {
    INSTANCE;
    public void whateverMethod() {
    }
}
总结
有两个问题需要注意：
1.如果单例由不同的类装载器装入，那便有可能存在多个单例类的实例。假定不是远端存取，例如一些servlet容器对每个servlet使用完全不同的类装载器，这样的话如果有两个servlet访问一个单例类，它们就都会有各自的实例。
2.如果Singleton实现了java.io.Serializable接口，那么这个类的实例就可能被序列化和复原。不管怎样，如果你序列化一个单例类的对象，接下来复原多个那个对象，那你就会有多个单例类的实例。
对第一个问题修复的办法是：
Java代码  收藏代码
private static Class getClass(String classname)      
                              throws ClassNotFoundException 
{     
      ClassLoader classLoader = 
Thread.currentThread().getContextClassLoader();     
      
      if(classLoader == null)     
         classLoader = Singleton.class.getClassLoader();     
      
      return (classLoader.loadClass(classname));       
}  
 对第二个问题修复的办法是：
Java代码  收藏代码
public class Singleton implements java.io.Serializable {     
   public static Singleton INSTANCE = new Singleton();     
      
   protected Singleton() {     
        
   }     
   private Object readResolve() {     
            return INSTANCE;     
      }    
}   
 
单例都是五种写法。懒汉，饿汉，双重校验锁，枚举和静态内部类。一般的情况下，我会使用饿汉方式，只有在要明确实现lazy loading效果时才会使用静态内部类方式，另外，如果涉及到反序列化创建对象时我会试着使用枚举的方式来实现单例。