【读书笔记】HeadFirst设计模式——单件不简单：详述实现Singleton模式需要考虑的方方面面
什么是单件？
单件就是保证一个类仅有一个实例，并提供一个访问它的全局访问点。——GOF
单件模式简单吗？
简单，的确简单，因为只有一个类。
单件不简单！
其实单件并不见得简单，而且还有点小复杂。其复杂度正是为了保证单件所要达到“仅有一个实例”的宏伟目标而引起的。
当然在一般情况下，单件是简单的。但是在考虑了懒加载、并发、反射、序列化、子类化等诸多因素后，为了保证只有一个实例，复杂度就大大提高了。
下面就从这些方面一一来看如何保证单件只有一个实例，然后看看是不是并不像想象的简单。
1.So easy!饿汉
很简单，直接访问静态域，为防修改，定义成final的。当然构造函数必须是私有的。
/**
* 最简单的单件实现,直接访问静态域
*
* @author nathan
*
*/
public class SimpleSingleton {
public final static SimpleSingleton INSTANCE = new SimpleSingleton();
private SimpleSingleton() {
}
public void doSomething() {
System.out.println("SimpleSingleton.doSomething");
}
}
2.1的变体
通过静态方法访问
/**
* 最简单的单件实现,访问静态方法
*
* @author nathan
*
*/
public class SimpleSingleton2 {
private final static SimpleSingleton2 INSTANCE = new SimpleSingleton2();
private SimpleSingleton2() {
}
public void doSomething() {
System.out.println("SimpleSingleton2.doSomething");
}
public static SimpleSingleton2 getInstance() {
return INSTANCE;
}
}
3.复杂度+1：反反射调用私有构造函数创建实例。
实现方式，在构造函数中判断是否为空，否则抛出异常
/**
* 反反射调用构造函数的单件实现
*
* @author nathan
*
*/
public class AntiRefSingleton {
public static AntiRefSingleton instance = new AntiRefSingleton();
private AntiRefSingleton() {
if (instance != null) {
throw new RuntimeException(
"This is a Singleton Class, please use AntiRefSingleton.instance to get the Object!");
}
}
public void doSomething() {
System.out.println("SimpleSingleton.doSomething");
}
}
3.复杂度+2：懒汉
为防止加载没用的加载比较耗时的单件
/**
* 懒加载的单件实现，但有并发问题
*
* @author nathan
*
*/
public class LazySingleton {
private static LazySingleton instance = null;
private LazySingleton() {
if (instance != null) {
throw new RuntimeException(
"This is a Singleton Class, please use the getInstance function to get the Object!");
}
}
public void doSomething() {
System.out.println("LazySingleton.doSomething");
}
public static LazySingleton getInstance() {
if (instance == null) {
instance = new LazySingleton();
}
return instance;
}
}
4.复杂度+3：并发控制
懒汉做事总是不靠谱，必须要有额外的机制保证线程安全——DCL（双重检查加锁）
/**
* 使用DCL技术实现的并发安全的懒加载单件实现
*
* @author nathan
*
*/
public class ConcurrentSingleton {
/**
* 必须声明为volatile的
*/
private static volatile ConcurrentSingleton instance = null;
private ConcurrentSingleton() {
if (instance != null) {
throw new RuntimeException(
"This is a Singleton Class, please use the getInstance function to get the Object!");
}
}
public void doSomething() {
System.out.println("ConcurrentSingleton.doSomething");
}
public static ConcurrentSingleton getInstance() {
if (instance == null) {// 使用双重检查锁定技术
synchronized (ConcurrentSingleton.class) {
if (instance == null) {
instance = new ConcurrentSingleton();
}
}
}
return instance;
}
}
5.懒汉变体
使用静态内部类，也是线程安全的
/**
* 使用静态内部类实现懒汉单例，而且是线程安全的
*
* @author nathan
*
*/
public class HolderSingleton {
private static class SingletonHolder {
private static final HolderSingleton INSTANCE = new HolderSingleton();
}
public static HolderSingleton getInstance() {
return SingletonHolder.INSTANCE;
}
}
6.复杂度+4：接下来考虑序列化
《Effective Java》中作者已经给出了方案，即添加readResolve方法。如下：
/**
* 可序列化的单件实现（同时是并发安全的懒加载的），但只能在同一个jvm中使用，不能跨jvm
*
* @author nathan
*
*/
public class SerializableSingleton implements Serializable {
private static final long serialVersionUID = 5691590550973506283L;
private transient String description;
public void doSomething() {
description = "SerializableSingleton";
}
@Override
public String toString() {
return super.toString() + " [description=" + description + "]";
}
/**
* 必须声明为volatile的
*/
private static volatile transient SerializableSingleton instance = null;
private SerializableSingleton() {
if (instance != null) {
throw new RuntimeException(
"This is a Singleton Class, please use the getInstance function to get the Object!");
}
}
public static SerializableSingleton getInstance() {
if (instance == null) {// 使用双重检查锁定技术
synchronized (SerializableSingleton.class) {
if (instance == null) {
instance = new SerializableSingleton();
}
}
}
return instance;
}
private Object readResolve() {
// 抛弃反序列化的实例，返回原实例
return instance;
}
}
7.复杂度+5：跨jvm序列化
第6中方案作者给出了解决问题的思路，但未真正解决序列化问题。因为它只能在同一个jvm中适应。但是在同一个jvm中序列化单例似乎意义不大。下面是kuajvm的单例实现方式。简单修改6中的readResolve方法即可。
/**
* 能跨jvm使用的可序列化的单件实现（同时是并发安全、懒加载的）
*
* @author nathan
*
*/
public class SerializableSingleton2 implements Serializable {
private static final long serialVersionUID = 5691590550973506283L;
private String description;
private int count;
public void doSomething() {
description = "SerializableSingleton2";
count = 100;
}
@Override
public String toString() {
return super.toString() + " [description=" + description + ",count="
+ count + "]";
}
public void setCount(int count) {
this.count = count;
}
public int getCount() {
return count;
}
/**
* 必须声明为volatile的
*/
private static volatile SerializableSingleton2 instance = null;
private SerializableSingleton2() {
if (instance != null) {
throw new RuntimeException(
"This is a Singleton Class, please use the getInstance function to get the Object!");
}
}
public static SerializableSingleton2 getInstance() {
if (instance == null) {// 使用双重检查锁定技术
synchronized (SerializableSingleton2.class) {
if (instance == null) {
instance = new SerializableSingleton2();
}
}
}
return instance;
}
private Object readResolve() {
if (instance == null) {// 使用双重检查锁定技术
synchronized (SerializableSingleton2.class) {
if (instance == null) {
instance = this;// 如果是第一次反序列化，则使用该实例，否则不管它
}
}
}
return instance;
}
public static void serialize(String file) throws Exception {
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(
new File(file)));
oos.writeObject(instance);
}
public static void antiSerialize(String file) throws Exception {
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(
new File(file)));
instance = (SerializableSingleton2) ois.readObject();
}
}
8.复杂度+6：考虑单件的继承
在GOF的《设计模式》中给出了方案，即采用register的方式。但按其书中描述，子类的构造函数必须是公有的，这就违背了单例的初衷。因此必须借助“反射”机制实现对子类的实例化。
9.复杂度+7：再考虑基于继承的单件体系的跨jvm的序列化
（8和9合后的并代码如下）
/**
* 一个可子类化、可序列化的单件实现
*
* @author nathan
*
*/
public class SubableSingleton implements Serializable {
private String description;
private int count;
public void doSomething() {
description = "SubableSingleton";
count = 100;
}
@Override
public String toString() {
return super.toString() + " [description=" + description + ",count="
+ count + "]";
}
public void setCount(int count) {
this.count = count;
}
public int getCount() {
return count;
}
// 以下代码实现单件支持
private static final long serialVersionUID = 5713856529741473199L;
private static SingletonHolder holder = null;
private String name;
protected SubableSingleton() {
this(SubableSingleton.class);
}
protected SubableSingleton(Class<? extends SubableSingleton> clazz) {
if (holder.lookup(clazz.getName()) != null) {
throw new RuntimeException(
"This is a Singleton Class, please use getInstance function to get the Object!");
}
name = clazz.getName();
}
/**
* 注意：使用synchronized代替DCL进行简单并发控制
*
* @param clazz
* @return
*/
public static synchronized SubableSingleton getInstance(
Class<? extends SubableSingleton> clazz) {
if (holder == null) {
holder = new SingletonHolder();
}
SubableSingleton instance = holder.lookup(clazz.getName());
if (instance == null) {
try {
Constructor<? extends SubableSingleton> constructor = clazz
.getDeclaredConstructor();
constructor.setAccessible(true);
instance = constructor.newInstance();
holder.register(clazz.getName(), instance);
} catch (Exception e) {
e.printStackTrace();
}
}
return instance;
}
private synchronized Object readResolve() {
System.out.println("SubableSingleton.readResolve");
if (holder == null) {
holder = new SingletonHolder();
holder.register(this.name, this);
}
return holder.lookup(this.name);
}
public static void serialize(String file) throws Exception {
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(
new File(file)));
oos.writeObject(holder);
}
public static void antiSerialize(String file) throws Exception {
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(
new File(file)));
holder = (SingletonHolder) ois.readObject();
}
/**
* 单例持有类，私有
*
* @author nathan
*
*/
private static class SingletonHolder implements Serializable {
private static final long serialVersionUID = -4221190210772287103L;
private Map<String, SubableSingleton> registry = new HashMap<String, SubableSingleton>();
public void register(String name, SubableSingleton subableSingleton) {
registry.put(name, subableSingleton);
}
public SubableSingleton lookup(String name) {
return registry.get(name);
}
private synchronized Object readResolve() {
System.out.println("SingletonHolder.readResolve");
// 抛弃反序列化的实例，返回原实例
if (holder == null) {
holder = this;
}
return holder;
}
}
}
/** * 子类必须在构造函数中调用父类的带参构造函数，完成反反射控制 * @author nathan * */
public class SubSingleton extends SubableSingleton {
private static final long serialVersionUID = 2430773476223417288L;
protected SubSingleton() {
super(SubSingleton.class);
}
}
那么，你还认为单件简单吗？欢迎交流！
参考：
GOF的《设计模式》
《Effective Java》
《单件模式的7种写法》http://www.360doc.com/content/10/1213/09/2703996_77599342.shtml
附：相关单元测试
public class SingletonTest {
@Test
public void testSimpleSingleton() {
Assert.assertEquals(SimpleSingleton.INSTANCE, SimpleSingleton.INSTANCE);
}
@Test
public void testSimpleSingleton2() {
Assert.assertEquals(SimpleSingleton2.getInstance(),
SimpleSingleton2.getInstance());
}
@Test
public void testAntiRefSingleton() throws Exception {
Assert.assertEquals(AntiRefSingleton.instance,
AntiRefSingleton.instance);
try {
Constructor<AntiRefSingleton> constructor = AntiRefSingleton.class
.getDeclaredConstructor();
constructor.setAccessible(true);
constructor.newInstance();
} catch (Exception e) {
e.printStackTrace();
}
}
@Test
public void testLazySingleton() {
Assert.assertEquals(LazySingleton.getInstance(),
LazySingleton.getInstance());
}
@Test
public void testConcurrentSingleton() {
Assert.assertEquals(ConcurrentSingleton.getInstance(),
ConcurrentSingleton.getInstance());
}
@Test
public void testSubableSingleton() {
Assert.assertNotNull(SubableSingleton
.getInstance(SubableSingleton.class));
Assert.assertTrue(SubableSingleton.getInstance(SubableSingleton.class) instanceof SubableSingleton);
Assert.assertEquals(
SubableSingleton.getInstance(SubableSingleton.class),
SubableSingleton.getInstance(SubableSingleton.class));
Assert.assertNotNull(SubableSingleton.getInstance(SubSingleton.class));
Assert.assertTrue(SubableSingleton.getInstance(SubSingleton.class) instanceof SubSingleton);
Assert.assertEquals(SubableSingleton.getInstance(SubSingleton.class),
SubableSingleton.getInstance(SubSingleton.class));
}
@Test
public void testSubableSingletonSerialize() throws Exception {
SubableSingleton instance = SubableSingleton
.getInstance(SubableSingleton.class);
SubableSingleton instance2 = SubableSingleton
.getInstance(SubSingleton.class);
instance.doSomething();
instance2.doSomething();
SubableSingleton.serialize("testSubableSingletonSerialize.jser");
SubableSingleton.antiSerialize("testSubableSingletonSerialize.jser");
Assert.assertEquals(instance,
SubableSingleton.getInstance(SubableSingleton.class));
Assert.assertEquals(instance2,
SubableSingleton.getInstance(SubSingleton.class));
}
@Test
public void testSubableSingletonSerialize2() throws Exception {
SubableSingleton.antiSerialize("testSubableSingletonSerialize.jser");
SubableSingleton instance = SubableSingleton
.getInstance(SubableSingleton.class);
SubableSingleton instance2 = SubableSingleton
.getInstance(SubSingleton.class);
Assert.assertEquals(100, instance.getCount());
Assert.assertEquals(100, instance2.getCount());
instance.setCount(20);
SubableSingleton.antiSerialize("testSubableSingletonSerialize.jser");
instance = SubableSingleton.getInstance(SubableSingleton.class);
Assert.assertEquals(20, instance.getCount());
}
@Test
public void testSubableSingletonSerialize3() throws Exception {
SubableSingleton instance = SubableSingleton
.getInstance(SubableSingleton.class);
instance.doSomething();
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(
new File("testSubableSingletonSerialize.jser")));
oos.writeObject(instance);
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(
new File("testSubableSingletonSerialize.jser")));
SubableSingleton instance2 = (SubableSingleton) ois.readObject();
Assert.assertEquals(instance, instance2);
}
@Test
public void testSubableSingletonSerialize4() throws Exception {
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(
new File("testSubableSingletonSerialize.jser")));
SubableSingleton instance2 = (SubableSingleton) ois.readObject();
Assert.assertEquals(100, instance2.getCount());
instance2.setCount(20);
ois = new ObjectInputStream(new FileInputStream(new File(
"testSubableSingletonSerialize.jser")));
instance2 = (SubableSingleton) ois.readObject();
Assert.assertEquals(20, instance2.getCount());
}
@Test
public void testSubableSingletonSerialize5() throws Exception {
SubableSingleton instance = SubableSingleton
.getInstance(SubSingleton.class);
SubableSingleton instance2 = SubableSingleton
.getInstance(SubSingleton.class);
instance.doSomething();
instance2.doSomething();
SubableSingleton.serialize("testSubableSingletonSerialize5.jser");
SubableSingleton.antiSerialize("testSubableSingletonSerialize5.jser");
Assert.assertEquals(instance,
SubableSingleton.getInstance(SubSingleton.class));
Assert.assertEquals(instance2,
SubableSingleton.getInstance(SubSingleton.class));
Assert.assertEquals(100, instance2.getCount());
}
@Test
public void testSerializableSingletonInOneJvm() throws IOException,
ClassNotFoundException {
Assert.assertEquals(SerializableSingleton.getInstance(),
SerializableSingleton.getInstance());
SerializableSingleton singleton = SerializableSingleton.getInstance();
singleton.doSomething();
System.out.println(singleton);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(singleton);
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais);
SerializableSingleton clone = (SerializableSingleton) ois.readObject();
System.out.println(clone);
Assert.assertEquals(singleton, clone);
clone.doSomething();
}
/**
* 在同一个jvm中，序列化后再反序列化对单件来说是无效的，jvm中始终使用的是最初创建的那个单件实例
*
* @throws Exception
*/
@Test
public void testSerializableSingleton2InOneJvm() throws Exception {
Assert.assertEquals(SerializableSingleton2.getInstance(),
SerializableSingleton2.getInstance());
SerializableSingleton2 singleton = SerializableSingleton2.getInstance();
singleton.doSomething();
Assert.assertEquals(SerializableSingleton2.getInstance().getCount(),
100);
SerializableSingleton2.serialize("SerializableSingleton2.jser");
// 序列化后改变实例数据
SerializableSingleton2.getInstance().setCount(30);
// 反序列化,实际上并未使用反序列化出来的实例，而是继续使用原来的实例，因为在同一个Jvm中
SerializableSingleton2.antiSerialize("SerializableSingleton2.jser");
// 因此这里的值是30,不是序列化时候的100
Assert.assertEquals(SerializableSingleton2.getInstance().getCount(), 30);
// 改变实例数据
SerializableSingleton2.getInstance().setCount(20);
// 再反序列化
SerializableSingleton2.antiSerialize("SerializableSingleton2.jser");
Assert.assertEquals(SerializableSingleton2.getInstance().getCount(), 20);
}
/**
* 在另一个jvm中启动反序列化<br>
* 注意：请先执行测试testSerializableSingleton2InOneJvm，再执行该测试
*
* @throws Exception
*/
@Test
public void testSerializableSingleton2NotInOneJvmRead() throws Exception {
// 反序列化,并创建单件实例，此后在该jvm中将一直使用该实例
SerializableSingleton2.antiSerialize("SerializableSingleton2.jser");
// 因此这里的值是序列化时候的100
Assert.assertEquals(SerializableSingleton2.getInstance().getCount(),
100);
// 改变实例数据
SerializableSingleton2.getInstance().setCount(20);
// 再反序列化
SerializableSingleton2.antiSerialize("SerializableSingleton2.jser");
Assert.assertEquals(SerializableSingleton2.getInstance().getCount(), 20);
}
}