单例模式各种写法比较

• 饿汉模式：在类加载时就完成了单例的实例化过程，而类加载本身是线程安全的，所以饿汉模式是线程安全的；

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

• 懒汉模式：

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

• 双重校验锁：

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

volatile 的作用：防止new 对象时 Java编译器 JIT 和CPU进行指令重排序，还有可见性;
synchronized的位置是为了尽量减小所得粒度；

• 枚举

public enum Singleton {
    INSTANCE;
    public void whateverMethod() {
    }
}

这种方式是Effective Java作者Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象，可谓是很坚强的壁垒啊，不过，个人认为由于1.5中才加入enum特性，用这种方式写不免让人感觉生疏。
即使私有化构造器还是可以通过反射拿到该类的对象实例，但是通过枚举的话，反射是不可以拿到对象的实例的 直接报异常了;

• 静态内部类：推迟了类加载时的实例化(懒加载)，只有调用getInstance方法时才会加载内部类，才会实例化对象；

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

注：内部类不会因为外部内的加载而加载；