单例模式

这一模式的目的是使得类的一个对象成为系统中的唯一实例。要保证构造函数私有。
java中单例的几种写法：

• 懒汉式(线程不安全)：

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

这种写法lazy loading很明显，但是致命的是在多线程不能正常工作。

• 懒汉(线程安全)

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

这种写法能够在多线程中很好的工作，而且看起来它也具备很好的lazy loading，但是，直接在方法上加synchronized，效率很低，99%情况下不需要同步。

• 双重检查锁

public class Singleton {  
    private volatile static Singleton singleton;  
    private Singleton (){}  
    public static Singleton getSingleton() {  
    if (singleton == null) {  
        synchronized (Singleton.class) {  
        if (singleton == null) {  
            singleton = new Singleton();  
        }  
        }  
    }  
    return singleton;  
    }  
}  

这个是上一种方式的升级版，俗称双重检查锁定，解决了上一种方式99%情况下不需要同步的弊端

• 饿汉

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

这种方式是在类被加载的时候创建对象，显然没有达到lazy loading的效果

• 静态内部类

public class Singleton {  
    private static class SingletonHolder {  
    private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
    return SingletonHolder.INSTANCE;  
    }  
}  

这种方式还是在类加载SingletonHolder 的时候创建对象，与前一个方式不同得是它在正在需要使用的时候getInstance才加载，达到了lazy loading的效果

• 枚举
  public enum Singleton {
  INSTANCE;
  }
  枚举天生就是线程安全的，而且还能防止反序列化重新创建新的对象。