设计模式（一）单例模式

饿汉模式：

package pattern_Singleton;
/**
 * 饿汉模式
 */
public class Singleton1 {
	//自行实例化
	private static final Singleton1 single = new Singleton1();
	//这个类不能在外面实例化
	private Singleton1() {
	
	}
	public static Singleton1 getInstance() {
		return single;
	}
}

懒汉模式：

package pattern_Singleton;

/**
 * 懒汉模式.在第一次调用的时候实例化
 */
public class Singleton2 {
	
	//注意：这里没有final
	private static Singleton2 single;
	
	//只实例化一次 （当你使用我的时候我才实例化）
	static{
		single = new Singleton2();
	}
	private Singleton2() {
	
	}
	//静态工厂方法
	public synchronized static Singleton2 getInstance() {
		if (single == null) {
			single = new Singleton2();
		}
		return single;
	}
        public static void main(String[] args){
        Singleton2 s1 = Singleton2.getInstance();
        Singleton2 s2 = Singleton2.getInstance();
        if(s1==s2){
            System.out.println("s1和s2是同一个实例");
        }else{
            System.out.println("s1和s2不是同一个实例");
        }
    }
       public static void main(String[] args){
        Singleton1 s1 = Singleton1.getInstance();
        Singleton1 s2 = Singleton1.getInstance();
        if(s1==s2){
            System.out.println("s1和s2是同一个实例");
        }else{
            System.out.println("s1和s2不是同一个实例");
        }
    }
 }

登记类型：

package pattern_Singleton;

import java.util.HashMap;
import java.util.Map;

/**
 * 登记模式
 * 
 */
public class Singleton3 {
	
	private static Map<String,Singleton3> map = 
			new HashMap<String,Singleton3>();
	static{
		System.out.println("i am static..");
		Singleton3 single = new Singleton3();
		map.put(single.getClass().getName(), single);
	}
	//保护类型构造
	protected Singleton3(){
		System.out.println("i am construct..");
	}
	//静态工厂方法,返还此类惟一的实例
	public static Singleton3 getInstance(String name) {
		if(name == null) {
			System.out.println("getnInstance...");
			name = Singleton3.class.getName();
			System.out.println("name == null"+"--->name="+name);
		}
		if(map.get(name) == null) {
			try {
				map.put(name, (Singleton3) Class.forName(name).newInstance());
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return map.get(name);
	}

	public String about() {
		return "Hello, I am RegSingleton.";
	}
	
	public static void main(String[] args) {
		Singleton3 single3 = Singleton3.getInstance(null);
		System.out.println(single3.about());
	}
}

基本上所有单例模式都列举出来了，当然还有一些变种不一一列举，接下来通过分析这三种单例模式，特别是使用场景，毕竟学以致用才是最关键的。

为什么用单例（WHY）

线程安全是开发过程中需要考虑的因素，单例模式就从线程安全引发。如果一段代码所在的进程中有多个线程在同时运行，如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。不用单例多浪费，性能随随便便就浪费了。

什么是单例（WHAT）

java中单例模式是一种常见的设计模式，单例模式分三种：懒汉式单例、饿汉式单例、登记式单例三种。
　　单例模式有以下特点：
　　1、单例类只能有一个实例。
　　2、单例类必须自己自己创建自己的唯一实例。
　　3、单例类必须给所有其他对象提供这一实例。

什么时候用单例（WHERE）

1.Windows的Task Manager（任务管理器）就是很典型的单例模式

2. windows的Recycle Bin（回收站）也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。

3. 网站的计数器，一般也是采用单例模式实现，否则难以同步。

4. 应用程序的日志应用，一般都何用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。

5. Web应用的配置对象的读取，一般也应用单例模式，这个是由于配置文件是共享的资源。

6. 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。数据库软件系统中使用数据库连接池，主要是节省打开或者关闭数据库连接所引起的效率损耗，这种效率上的损耗还是非常昂贵的，因为何用单例模式来维护，就可以大大降低这种损耗。

总结：

　　（1）资源共享的情况下，避免由于资源操作时导致的性能或损耗等。如上述中的日志文件，应用配置。

　　（2）控制资源的情况下，方便资源之间的互相通信。如线程池等。

如何使用单例（HOW）

饿汉、懒汉区别：

饿汉模式：不管用不用，类加载时就创建。

懒汉模式：用到的时候才去创建。和饿汉的区别在于对象实例化的时间有区别。

从性能上讲懒汉式比饿汉式更加优越，在此基础上改进了懒汉式，即成了登记式。

不论饿汉还是懒汉都不能被继承，因为私有构造。登记模式的出现解决这个问题。提供保护类型的构造类型，并开放一个公有方法getInstance。允许同包和子类实例化，和调用此公有方法。（因此在使用登记单例时，将此放入单独包中）。

登记模式实际对一组单例模式进行的维护，主要是在数量上的扩展，通过map我们把单例存进去，这样在调用时，先判断该单例是否已经创建，是的话直接返回，不是的话创建一个登记到map中，再返回。对于数量又分为固定数量和不固定数量的。

饿汉、懒汉、登记三种方式实现了单例模式。他们基本上都是通过构造方法的私有化实现了实例的唯一性（通过反射机制可以获取对象实例，难道单例和反射不能同时出现），我认为凡是能够满足“只有自己创建唯一实例”的书写技巧都可以称为单例模式。

以上就是我的3W1H学习方法，不对的地方还请指正。