设计模式 单例模式

单例模式(Singleton)：

   保证一个类仅有一个实例，并提供一个访问它的全局访问点。

 

   通常我们可以设定一个全局变量使得一个对象被访问，但不能阻止你实例化多个对象。

   最好的办法是：

        让类自身负责保存它的唯一实例。这个类可以保证没有其他实例被创建，并且它可以提供一个访问该实例的方法。

 

 

   JAVA的单例有以下几种实现方式：

   1.饿汉式

      在类初始化时，实例化本身。

 

/**
 * 饿汉式单例模式
 * @author wsg
 *
 */
public class Singleton {
	private static final Singleton singletonInstance = new Singleton();
	
	/**
	 * 私有构造函数
	 */
	private Singleton(){		
	}
	
	/**
	 * 返回该单例实例
	 * @return Singleton
	 */
	public static Singleton getInstance(){
		return singletonInstance;
	}
}

 

  2.懒汉式 - 延迟加载

     在第一次类调用的时候实例化.

 

/**
 * 懒汉式单例模式
 * @author wsg
 *
 */
public class Singleton {
	private static Singleton singletonInstance = null;
	
	/**
	 * 私有构造函数
	 */
	private Singleton(){
		
	}
	
	/**
	 * 返回该单例实例
	 * @return Singleton
	 */
	public synchronized static Singleton getInstance(){
		if(null==singletonInstance){
			singletonInstance = new Singleton();
		}
		return singletonInstance;
	}
}

 

 3.基于注册的单例模式

    避免在编译期指定单例类的不灵活方式

 

import java.util.HashMap;

/**
 * 基于注册的单例模式
 * 
 * @author wsg
 * 
 */
public class Singleton {
	private static HashMap regMap = new HashMap();

	/**
	 * 私有构造函数
	 */
	private Singleton() {
	}

	/**
	 * 返回该单例实例
	 * 
	 * @return Singleton
	 */
	public synchronized static Singleton getInstance(String className) {
		Singleton singleton = (Singleton) regMap.get(className);
		if (singleton == null) {
			try {
				singleton = (Singleton) Class.forName(className).newInstance();
			} catch (ClassNotFoundException cnf) {
				System.out.println("Couldn't find class " + className);
			} catch (InstantiationException ie) {
				System.out.println("Couldn't instantiate an object of type " + className);
			} catch (IllegalAccessException ia) {
				System.out.println("Couldn't access class " + className);
			}
			regMap.put(className, singleton);
		}
		return singleton;
	}

	/**
	 * 防止通过序列化之后的重构来得到不同的实例
	 * 
	 * @return
	 */
	private Object readResolve() {
		return this.getInstance(this.getClass().getName());
	}
}

 

 单例模式所要避免的一些问题：

   1.在懒汉式单例中，构造函数的私有private ,会导致该类无法进行扩展，不能继承。

      此时还不如声明该类为final，这样意图明显，还可以让编译器更好的进行性能优化。

 

      如果不是用private,而使用protocted,则在该单例内所属包下别的类依旧可以new Singleton(),

      此时出现的情形与单例模式相左。

      解决方案是：把该单例类放入一个外在的包中，以避免其他类实例化该单例类。

 

   2.如果单例由不同的类装载器装入，那便有可能存在多个单例类的实例。

      假定不是远端存取，例如一些servlet容器对每个servlet使用完全不同的类装载器，这样的话如 果有两个servlet访问 一个单例类，它们就都会有各自的实例。 

 

   3.如果Singleton实现了java.io.Serializable接口，那么这个类的实例就可能被序列化和复原。

      如果你序列化一个单例类的对象，接下来复原多个那个对象，那你就会有多个单例类的实例。

 

   4.线程安全问题。

      如果Singleton类不是线程安全的。有两个线程，我们称它们为线程1和线程2，在同一时间调用

      getInstance()方法，线程1先进入if块，然后线程2进行控制。

      此时就会产生两个Singleton实例。