概念
顾名思义，就是无论如何，只让生成一个实例对象的模式了。本篇主要介绍几种单例模式的写法。
懒汉式，线程不安全
最基本的实现，但最大的问题就是不支持多线程。
public class LazeM {
private static LazeM lazem;
private LazeM(){}
public static LazeM getInstance(){
if(lazem==null){
lazem = new LazeM();
}
return lazem;
}
}
懒汉式，线程安全
这种模式，相较于前一种，添加了synchronized关键字。支持多线程，但是效率比较低。
public class LazySafe {
private static LazySafe lazy;
private LazySafe(){};
public static synchronized LazySafe getInstance(){
if(lazy==null){
lazy = new LazySafe();
}
return lazy;
}
}
饿汉式、线程安全
这种模式，多线程时安全的，但是很明显，不是懒加载。
public class Lazy {
private static Lazy lazyInstance = new Lazy();
private Lazy(){};
public static Lazy getInstance(){
return lazyInstance;
}
}
双重检查锁（dcl）
这种模式，效率高，支持多线程，而且好多面试java的时候愿意问这个。
public class Dcl {
private volatile static Dcl dcl;
private Dcl(){}
public static Dcl getInstance(){
if(dcl==null){
synchronized(Dcl.class){
if(dcl==null){
dcl = new Dcl();
}
}
}
return dcl;
}
}
静态内部类
这种方式能达到双检锁方式一样的功效，但实现更简单。
public class StaticM {
private static class StaticMHolder{
private static final StaticM staticM = new StaticM();
}
private StaticM(){}
public static final StaticM getInstanc(){
return StaticMHolder.staticM;
}
}
枚举
这种方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。
public enum Singleton {
INSTANCE;
public void whateverMethod() {
}
}
The End
所有的单例模式都需要把构造函数设置位private。一般情况下，建议使用饿汉式单例，如果明确需要懒加载的话，可以使用静态内部类的方式。当然，dcl也是很好用的。
