单例模式（singleton）的五种方式

//懒汉模式
//实现多线程同步，效率比较低
public class Singleton1 {
	private static Singleton1 instance = null;
	//构造函数定义成private，禁止外部创建Singleton实例
	private Singleton1(){}
	public static synchronized Singleton1 getInstance(){
		if(instance == null){
			instance = new Singleton1();
		}
		return instance;
	}
}

//饿汉模式
//避免了多线程的同步问题，装载的时候就实例化
public class Singleton2 {
	private static Singleton2 instance = new Singleton2();
	private Singleton2(){}
	public static Singleton2 getInstance(){
		return instance;
	}
}


/*静态内部类
* 装载的时候会不会实例化，只有当调用getInstance方法，才会装载NewSingleton
* 类从而实例化
* */
public class Singleton3 {
	private static class NewSingleton{
		private static final Singleton3 instance = new Singleton3();
	}
	private Singleton3(){}
	public static final Singleton3 getInstance(){
		return NewSingleton.instance;
	}
}

//双重校验锁，是懒汉模式的升级版
public class Singleton4 {
	//使用volatile修饰，被volatile修饰的变量的值，不会被本地线程缓存，所有对
	//该变量的读写都是直接操作共享内存的，从而保证多个线程能正确处理该变量
	private volatile static Singleton4 instance = null;
	private Singleton4(){}
	public static Singleton4 getInstance(){
		if(null == instance){
			synchronized(Singleton4.class){
				if(null == instance){
					instance = new Singleton4();
				}
			}
		}
		return instance;
	}
}


//登记模式
public class Singleton5 {
	private static Map<String,Singleton5> map = new HashMap<String, Singleton5>();
	static{
		Singleton5 singleton = new Singleton5();
		map.put(singleton.getClass().getName(), singleton);
	}
	protected Singleton5(){}
	public static Singleton5 getInstance(String name){
		if(null == name){
			name = Singleton5.class.getName();
		}
		if(null ==map.get(name)){
			try {
				map.put(name, (Singleton5)Class.forName(name).newInstance());
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return map.get(name);
	}
}