《Head First设计模式》阅读笔记.第五章

1.单件（单态，Singleton）模式部分

*有些对象我们只需要一个，比如说：线程池（threadpool）、缓存（cache）、对话框（）、处理偏好设置的对象、处理注册表（register）的对象、日志对象，以及充当打印机、显卡等设备的驱动程序对象。这些对象只能有一个实例，如果出现多个实例就会导致程序的行为异常、资源使用过量，或者产生的结果不一致等等问题。

*单件模式与全局静态变量的区别：
（1）使用全局静态变量需要程序员之间的约定才能保证只有一个实例，而单件模式无需这样的约定就可以确保只有一个实例被创建。
（2）静态变量在程序一开始就被创建（这取决于JVM的实现），而单件模式只是在使用时才创建对象。如果这个被创建的对象非常消耗资源，而在程序运行的过程中没有用到它，就会造成很大的浪费，这是静态变量的缺点。

*在单态模式中，如果不需要这个实例，它就永远不会被创建。这就是“延迟实例化（Lazy Instance）”。

*单件模式的应用场景之一是设置类对象，比如注册表设置（Register Setting）对象。如果设置对象有多份拷贝，就会把设置搞得一团糟。

*单件常用来管理共享的资源，比如数据库连接池或线程池。

单件（Singleton）模式：确保一个类只有一个实例，并提供一个全局访问点。

*多线程会影响到单件模式，如果不对它进行处理就会在单件模式下仍然创建多于一个实例。
解决这个问题有以下三种方式：
（1）使用同步。但是简单地给创建实例方法（getInstance()）增加synchronized修饰符虽然可以解决多线程的问题，但是导致每次调用都同步，而在静态变量被设置之后，同步就是多余的了，因此，这降低了程序的效率。
在程序频繁运行的地方增加同步可能会使效率降低100倍！因此要尽量避免使用同步，如果使用，就要尽量缩减需要同步的代码。
方法如下：

------------
public class Singleton {
	private static Singleton instance;

	private Singleton() {}

	public synchronized static Singleton getInstance() {
	    if (instance == null) {
	        instance = new Singleton();
	    }
	    return instance;
	}
}
------------

（2）使用“急切（eagerly）”创建实例，也就是在生命静态变量的时候就创建实例，而不是等到使用的时候再创建。该方式适用于程序总是需要创建和使用单件实例、程序在创建和运行时负担不是太重、单件实例占用的资源较少的情况。
方法如下：

------------
public class Singleton {
    private static Singleton instance = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() {
        return instance;
    }
}
------------

（3）在创建实例方法（getInstance()）方法中使用“双重检查加锁（Double-Checked Locking）”，这样既保持了“延迟实例化（Lazy Instance）”，又保证只在第一次调用时同步。
方法如下：

------------
public class Singleton {
	private volatile static Singleton instance;

	private Singleton() {}

	public static Singleton getInstance() {
	    if (instance == null) {
	        synchronized (Singleton.class) {
	            if (instance == null) {
	                instance = new Singleton();
	            }
	        }
	    }
	    return instance;
	}
}
------------

在这个方法里使用到了volatile这个关键字，下面对这个“关键的”关键字进行说明：
Java语言规范指出，为了获得最佳速度，允许线程保存共享成员变量的私有拷贝，而且只当线程进入和离开同步代码块时才与共享成员变量的原始值进行对比。
而被volatile修饰的成员变量在线程中的私有拷贝每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量的私有拷贝发生变化时，强迫线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
因此volatile关键字是使“双重检查加锁（Double-Checked Locking）”有效的前提。
但是需要注意，在1.4及以前版本的JDK中，JVM对volatile关键字的实现会导致双重检查加锁失效，所以这个方法只适用于1.5（包含）以后版本。

*以上对三种处理多线程方法的总结也就是“Sharpen Your Pencil”的解答。

*可以通过把一个类中的全部方法都定义为静态方法的方式来达到和单件模式同样的效果，但是由于类的初始化顺序由JVM控制，所以可能导致与初始化顺序有关的BUG，而这样的BUG常常难于被发现。当类的初始化比较简单时，可以使用此方法。

*类加载器会破坏单件模式，因为不同的类加载器可以分别创建同一个单件的对象，单件对象就有了多个实例。解决办法是：自行指定类加载器，并且指定同一个类加载器。

*在Java 1.2及以前版本中，垃圾收集器有一个BUG，会造成单件在没有全局引用时，被当做垃圾清理掉。在1.2以后的版本中，这个BUG已经得到了修复，因此不用担心了。
如果使用的是1.2及以前的版本，可以建立一个单件注册表（Register），从而避免单件被垃圾收集器回收。

*虽然单件模式不支持继承，但在一个软件中用到它的机会并不多，所以这个限制几乎没有影响。

*Java中实现单件（Singleton）模式需要私有的构造器、一个静态变量和一个静态方法。

2.单件（Singleton）模式实例

第一种实现：

public class ThreadPool {
	private static ThreadPool instance;

	private ThreadPool() {
	}

	public synchronized static ThreadPool getInstance() {
		if (instance == null) {
			instance = new ThreadPool();
		}
		return instance;
	}
}

第二种实现：

public class DBConnectionPool {
	private static DBConnectionPool instance = new DBConnectionPool();

	private DBConnectionPool() {
	}

	public static DBConnectionPool getInstance() {
		return instance;
	}
}

第三种实现（适用于1.5及以后版本）：

public class LogFactory {
	private volatile static LogFactory instance;

	private LogFactory() {
	}

	public static LogFactory getInstance() {
		if (instance == null) {
			synchronized (LogFactory.class) {
				if (instance == null) {
					instance = new LogFactory();
				}
			}
		}
		return instance;
	}
}

--END--