单例设计模式的7种实现方法

单例模式可以简单的理解为在一个特定范围内只有一份，并且提供一个全局访问点可以访问这个实例。
单例模式应用分析：
优势：科学使用资源，避免频繁创建，销毁对象时造成的资源浪费。
劣势：设计不够严谨会存在线程安全问题，可扩展性相对较差。

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

第一种单例方法在单线程的时候不会报错，但在多线程的环境下并不安全

//Singleton02
public class Singleton02{
	private Singleton02(){}
	private static Singleton02 instance;
	//在方法上加锁保证线程安全
	public static synchronized Singleton02 getInstance(){
		if(instance==null){
			instance=new Singleton02();
		}
		return instance;
	}
}

//Singleton03
//适用场景：大对象，稀少用，经常适用会造成线程阻塞
public class Singleton03{
	private Singleton03(){}
	private static Singleton03 instance;
	//使用同步方法块，在老版本的synchronized中同步方法快的效率会比同步方法更高，但现在几乎没有差别
	public static Singleton03 getInstance(){
		synchronized(Singleton03.class){
			if(instance==null){
				instance=new Singleton03();	
			}
		}
		return instance;
	}
}

/**Singleton04
 *基于Singleton03做优化
 *适用场景：大对象，稀少用
 */
public class Singleton04{
	private Singleton04(){}
	//volatile关键字可以保证操作可见性，禁止指令重排序
	private static volatile Singleton04 instance;
	public static Singleton04 getInstance(){
		if(instance==null){//双重判断机制，提高效率
			synchronized(Singleton04.class){
				if(instance==null){
					instance=new Singleron04();
				}
			}
		}
		return instance;
	}
}

//Singleton05
//适用场景：小对象，频繁使用
//在类加载时就创建对象
public class Singleton05{
	private Singleton05(){}
	private static Singleton05 instance=new Singleton05();
	public static Singleton05 getInstance(){
		return instance;
	}
}

//Singleton06
//适用场景：大对象，频繁访问
//基于内部类实现对象的延迟加载
public class Singleton06{
	private Singleton06(){}
	static class Inner{
		private static Singleton06 instance=new Singleton06();
	}
	public static Singleton06 getInstance(){
		return Inner.instance;
	}
}

//Singleton07
//基于枚举类型创建单例对象
//适用场景：小对象，频繁访问
//在类加载时创建对象
public enum Singleton07{
	instance;
	private Singleton07(){}
}