Java单例模式解析

单例模式主要关键点：

1.构造函数不对外开放，一般为private；

2.通过一个静态方法或者枚举返回单例类对象；

3.确保单例类的对象有且只有一个，尤其是在多线程下；

4.确保单例类对象在反序列化时不会重新构建对象；

通过将单例类的构造函数私有化，使得客户端不能通过new的形式手动构造单例类的对象。单例类会暴露一个共有静态方法，客户端需要调用这个静态方法获取到单例唯一函数，在获取这个单例的过程中比较中比较快困难的方法。

/*=================单例模式之懒汉模式=======================*/
	/**
	 * 懒汉模式：getIntance()方法中添加了synchronized关键字
	 * 也就是getIntance()是一个同步方法，这就保证了在多线程情况下单例对象唯一性
	 * 但是有一个问题，即使instance已经被初始化（第一次调用时就会被初始化instance）
	 * 每次用getInstance方法都会同步，这样就会消耗不必要的资源
	 * 懒汉单例模式的优点是单例只有在使用时才会被实例化，在一定程度上节约了资源；
	 * 缺点是第一次加载时需要及时进行实例化，反应稍慢，最大的问题是每次调用getIntance
	 * 都进行同步，造成不必要的同步开销，这种模式不建议使用
	 */
	public class Singleton{
		private static Singleton instance;
		private Singleton(){		
		}
		public static synchronized Singleton getIntance(){
			if(instance==null){
				instance=new Singleton();
			}
			return instance;
		}
	}
/*=========================================================*/

/*=================单例模式之饿汗模式=======================*/

	/**
	 * 饿汗模式：不能通过new的形式构造对象，只能通过Singleton.getSingleton函数
	 * 来获取，而这个Singleton是静态对象，并且在声明的时候就已经初始化，这就保证了
	 * Singleton对象的唯一性。这个实现的核心在于将Singleton类构造方法的私有化，使得
	 * 外部程序不能通过构造函数来构造Singleton对象，而Singleton类通过一个静态方法
	 * 返回一个静态对象
	 */
	public class Singleton {
		private static final Singleton singleton=new Singleton();
		/**
		 * 构造函数私有
		 */
		private Singleton(){
			
		}
		
		/**
		 * 共有的静态函数，对外暴露获取单例对象的接口
		 * @return
		 */
		public static Singleton getSingleton(){
			return singleton;
		}
	}
/*=========================================================*/

/*=================单例模式之Double CheckLock(DCL)模式=======================*/
	/**
	 * DCL模式：DCL方式实现单例模式的优点是既能够在需要时才初始化单例，有能够保证
	 * 线程安全，且单例对象初始化后调用getIntance不进行同步锁
	 * 可以看到getIntance方法中对instance进行了两次判空：第一次判断主要是为了避免
	 * 不可必要的同步，第二层的判断是为了在null的情况下创建实例
	 * DCL的优点：资源利用率高，第一次执行getIntance时单例对象才会被实例化，效率高
	 * 缺点：第一次加载时反应慢，也由于java内存模型的原理偶尔会失败。在高并发环境下
	 * 也有一定得缺陷，虽然发生概率很小。DCL模式是使用最多的单例实现方式，它能够在需
	 * 要时才实例化单例对象，并且能够在绝大多数场景下保证单例对象的唯一性，除非你的代
	 * 码在并发场景比较复杂或者低于JDK 6版本下使用，否则，这个方式一般能够满足需求
	 */
	public class Singleton{
		
		private static volatile Singleton instance;//注意volatile的使用
		private Singleton(){		
		}
		public static Singleton getIntance(){
			if(instance==null){
				synchronized(Singleton.class){
					if(instance==null){
						instance=new Singleton();
					}
				}
				
			}
			return instance;
		}
	}
/*=========================================================*/

/*=================单例模式之静态内部类模式=======================*/
	/**
	 * 静态内部类实现单例模式：DCL虽然在一定程度上解决了资源消耗、多余的同步、线程安全
	 * 等问题，但是，它还是在某些情况下出现失效的问题。这个问题被称为双层检查锁定（DCL）
	 * 失效，所以建议使用如下代码替代：
	 * 当第一次加载Singleton类是并不会初始化sInstance，只有在第一次调用Singleton的
	 * getInstance方法是才会导致sInstance被初始化，因此，第一次调用getInstance方法会
	 * 导致虚拟机加载SingletonHolder类，这种方式不仅能够确保线程安全，也能够保证单例
	 * 对象的唯一性，同时也延迟了单例的实例化，所以这是推荐使用的单例模式实现方式
	 */
	public class Singleton{
		private Singleton(){		
		}
		public static Singleton getIntance(){
			return SingletonHolder.sIntance;
		}
		private static class SingletonHolder{
			private static final Singleton sIntance=new Singleton();
		}
	}
/*=========================================================*/

/*=================单例模式之枚举单例模式=======================*/
/**
* 写法简单是枚举单例最大的优点，枚举在Java中与普通的类是一样的，不仅能够有字段
* 还能够有自己的方法。最重要的是默认枚举实例的创建时线程安全的，并且在任何情况
* 下它都是一个单例
* @author zyc
*
*/
public enum Singleton{
INSTANCE;
private Singleton(){

}
}

/*=========================================================*/

/*=================单例模式之容器实现=======================*/
	/**
	 * 在程序的初始，将多种单例类型注入到一个统一的管理类中，在使用时根据key获取对象
	 * 对应类型的对象，这种方式使得我们可以管理多种类型的单例，并且在使用时可以统一的
	 * 接口进行获取操作，降低了用户的使用成本，也对用户隐藏了具体的实现，降低耦合度
	 * @author zyc
	 *
	 */
	public class SingletonManager{
		private static Map <String,Object> objMap=new HashMap<String,Object>();
		private SingletonManager(){
			
		}
		public static void registerService(String key,Object instance){
			if(!objMap.containsKey(key)){
				objMap.put(key, instance);
			}
		}
		public static Object getService(String key){
			return objMap.get(key);
		}
	}
/*=========================================================*/