[设计模式] 单例模式

 

单例模式是运用频率很高的模式，由于在客户端通常没有高并发的情况，因此选择哪种实现方式并不会有太大的影响，出于效率考虑建议使用（DCL）双重检查锁定单例 与 静态内部类单例

 

使用场景

  确保某个类有且只有一个对象的场景，避免产生多个对象消耗过多的资源，或者某种类型的对象只应该有且只有一个。例如，创建一个对象需要消耗的资源过多，如要访问IO和数据库等资源，这时就要考虑使用单例模式

 

UML类图

 

静态内部类单例模式

 

 * 特点：当第一次加载Singleton类时并不会初始化sInstance，只有在第一次调用Singleton的getInstance方法时才会导致sInstance被初始化。因此，一次调用getInstance方法会导致虚拟机
 * 加载SinngletonHolder类
 * >>>>>>这种方式不仅能够确保线程安全，也能够保证单例对象的唯一性，同时也延迟了单例的实例化，所以这是推荐使用的单例模式实现方式
 * @author Administrator
 *
 */
public class Singleton {

	private Singleton() {
		// TODO Auto-generated constructor stub
	}
	
	public static Singleton getInstance(){
		return SingletonHolder.sInstance;
	}
	
	/**
	 * 静态内部类
	 */
	private static class SingletonHolder{
		private static Singleton sInstance = new Singleton();
	}
	
}

 

 

 

 

 

 

 

Double Check Lock(DCL) 双重检查锁定

 

 * 特点：DCL方式实现单例模式的优点是既能够在需要时才初始化单例，又能够保证线程安全且单例对象初始化后调用getInstance不进行同步锁
 * @author Administrator
 * 
 * 优点：资源利用率高，第一次执行getInstance时单例对象才会被实例化，效率高。
 * 缺点：第一次加载时反应稍慢，也由于Java内在模型的原因偶尔会失效，高并发环境下也有一定的缺陷
 * 
 * 能够在绝大多数场景下保证单例对象的唯一性，除非你的代码在并发场景比较复杂或者低于JDK 6版本下使用，否则，这种方式一般能够满足需求
 *
 */
public class Singleton1 {
	private static volatile Singleton1 sInstance = null;  //volatile JDK1.5后加入，可以保证对象每次都是从主内在中读取
	private Singleton1() {
		
	}
	
	public static Singleton1 getInstance(){
		if(sInstance == null){ //为了避免不必要的同步
			synchronized (Singleton1.class) {
				if(sInstance == null){ //为了在null的情况下创建实例
					sInstance = new Singleton1();
				}
			}
		}
		return sInstance;
	}
	
}

饿汉单例

 

 

 

 

 * 声明静态对象时就已经初始化
 * @author Administrator
 *
 */
public class Singleton2 {
	
	
	private static Singleton2 sInstance = new Singleton2();
	
	private Singleton2() {
		
	}
	
	public static Singleton2 getInstance(){
		return sInstance;
	}
	
}

懒汉单例

 

 

 

 

 * 优点：单例只有在使用时才会被实例化，在一定程度上节约了资源
 * 缺点：第一次加载时需要及时进行实例化，反应稍慢，最大的问题是每次调用getInstance都进行同步，造成不必要的同步开销
 *   一般不建议使用
 * @author Administrator
 *
 */
public class Singleton3 {

	private static Singleton3 sInstance = null;
	
	private Singleton3() {
		
	}
	
	//缺点：即使instance已经被初始化，每次调用getInstance方法都会进行同步，这样会消耗不必要的资源
	public static synchronized Singleton3 getInstalce(){
		if(sInstance == null){
			sInstance = new Singleton3();
		}
		return sInstance;
	}
	
}

枚举单例

 

 

 

 

/**
 * 默认枚举实例的创建是线程安全的，并且在任何情况下它都是一个单例
 * 即使反序列化它也不会重新生成新的实例 
 * @author Administrator
 *
 */
public enum SingleTonEnum {
	INSTANCE;
	
	public void doSomething(){
		System.out.println("do sth.");
	}
}

使用容器实现单例模式

 

 

 

 

/**
 * 使用容器实现单例模式
 * 这种方式使得我们可以管理多种类型的单例，并且在使用时可以通过统一的接口进行获取操作，降低了用户的使用成本，也对用户隐藏了具体实现，降低了耦合度
 * @author Administrator
 *
 */
public class SingletonMananger {
	private static Map<String,Object> objMap = new HashMap<String, Object>();
	
	private SingletonMananger() {}
	
	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);
	}
	
}

 

 

优点：

    1.由于单例模式在内在中只有一个实例，减少了内存开支，特别是一个对象需要频繁地创建，销毁时，而且创建或销毁时性能又无法优化，单例模式的优势就非常明显

    2.由于单例模式只生成一个实例，所以，减少了系统的性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时

       直接产生一个单例对象，然后用永久驻留内存的方式来解决。

    3.单例模式可以避免对资源的多重占用，例如一个写文件操作，由于只有一个实例存在内存中，避免对同一个资源文件的同时写操作。

    4.单例模式可以在系统设置全局的访问点，优化和共享资源访问，例如：可以设计一个单例类，负责所有数据表的映射处理

缺点：

    1.单例模式一般没有接口，扩展很困难，若要扩展，除了修改和代码基本上没有和二种途径可以实现。

    2.单例对象如果持有Conntext，那么很容易引发内存泄漏，此时需要注意传递给单例对象的Context最好是Application Context.