设计模式-单例模式

1. 单例模式
Ensure a class has only instance, and provide a global point of access to it .
(确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。)

/** 
	 * ClassName:Singleton <br/> 
	 * Function: 单例模式的通用实现方法. <br/> 
	 * Reason:   单例模式的通用实现方法. <br/> 
	 * Date:     2013年11月17日 下午3:16:22 <br/> 
	 * @author   zhangzhaoyu 
	 * @version   
	 * @since    JDK 1.7 
	 * @see       
	 */
	public class Singleton {
		
		private static final Singleton singleton = new Singleton();
		
		private Singleton() {}
		
		public static Singleton getSingleton() {
			return singleton;
		}
		
		public static void doSomething() {
			
		}
	}
	
	// 线程不安全的单例
	public class Singleton {
		private static Singleton singleton = null;
		
		private Singleton() {}
		
		public static Singleton getSingleton() {
			if (singleton == null) {
				singleton = new Singleton();
			}
			return singleton;
		}
	}

单例模式的优点：
（1）减少了内存的开销
（2）减少系统性能开销
（3）单例模式可以避免对资源的多重占用，例如写文件动作，由于一个实例存在内存中，避免对一个资源文件的
同时写操作。
（4）单例模式可以在系统设置全局的访问点，优化和共享资源访问，例如可以设计一个单例类，负责所有数据表
映射处理。

单例模式的使用场景：
（1）要求生成唯一的序列号的环境。
（2）整个项目中需要一个共享访问点或共享数据，例如一个Web页面上面的计数器，可以不把每次刷新纪录到数
据库中，使用单例模式保持计数器的值，并确保是线程安全的。
（3）穿件一个对象需要消耗过多的资源，例如访问IO和数据库等资源。
（4）需要定义大量的静态常量和静态方法的环境，可以采用单例模式，也可以直接使用static 声明。

        单例模式处理多线程访问安全性问题：
        （1）加锁（synchronized）开销太大，影响性能

public class Singleton {

	private static Singleton singleton;
	private String name;
	
	private Singleton() {}
	
	public static synchronized Singleton getInstance() {
		if (singleton == null) {
			singleton = new Singleton();
		}
		return singleton;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public String getName() {
		return this.name;
	}
	
	public String toString() {
		return "Singleton[name=" + this.name + "]";
	}
}

（2）急切的创建实例

public class Singleton2 {

	private static Singleton2 singleton = new Singleton2();
	private String name;
	
	private Singleton2() {}
	
	public static Singleton2 getInstance() {
		return singleton;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public String getName() {
		return this.name;
	}
	
	public String toString() {
		return "Singleton[name=" + this.name + "]";
	}
}

        （3）保证性能的同步方式

public class Singleton2 {

	private static volatile Singleton2 singleton;
	private String name;
	
	private Singleton2() {}
	
	public static Singleton2 getInstance() {
		if (singleton == null) {
			synchronized (Singleton2.class) {
				if (singleton == null) {
					singleton = new Singleton2();
				}
			}
		}
		return singleton;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public String getName() {
		return this.name;
	}
	
	public String toString() {
		return "Singleton[name=" + this.name + "]";
	}
}

单例模式的扩展（有上限的单例模式）
该种模式是单例模式的扩展，我们可以在设计时就决定内存中有多少个实例，方便系统进行扩展。修正单利可能
存在的性能问题，提高系统的响应速度。例如读取文件，可以在系统启动时完成初始化工作。

	/** 
	 * ClassName:Emperors <br/> 
	 * Function: fixed size. <br/> 
	 * Reason:   fixed size. <br/> 
	 * Date:     2013年11月17日 下午3:38:24 <br/> 
	 * @author   zhangzhaoyu 
	 * @version   
	 * @since    JDK 1.7 
	 * @see       
	 */
	public class Emperors {
		
		private static int maxNumOfEmperor = 2;
		private static ArrayList<String> nameList = new ArrayList<String>();
		private static ArrayList<Emperors> emperorList = new ArrayList<Emperors>();
		private static int countNumOfEmperor = 0;
		
		static {
			for (int i=0; i<maxNumOfEmperor; i++) {
				emperorList.add(new Emperors("King " + (i+1)));
			}
		}
		
		public Emperors() {}
		
		public Emperors(String name) {
			nameList.add(name);
		}
		
		public static Emperors getInstance() {
			Random random = new Random();
			countNumOfEmperor = random.nextInt(maxNumOfEmperor);
			return emperorList.get(countNumOfEmperor);
		}
		
		public static void say() {
			System.out.println(nameList.get(countNumOfEmperor));
		}
	}