Java设计模式-单例模式分析

单例模式的应用场景

单例模式（Singleton Pattern）是指确保一个类在任何情况下都绝对只有一个实例，并 提供一个全局访问点。单例模式是创建型模式。单例模式在现实生活中也很常见。 例如，父亲、母亲等。在J2EE标准中，ServletContext、ServletContextConfig 等；在 Spring 框架应用中ApplicationContext；数据库的连接池也是单例的形式。

饿汉式单例

饿汉式单例是在类加载的时候就立即初始化，并且创建单例对象。绝对线程安全，在线程还没出现以前就是实例化了，不可能存在访问安全问题。
优点：不牵扯锁、执行效率相对来说比较高，在用户体验上比懒汉式更好一些。
缺点：类加载就初始化，导致用不用都占用空间，可能导致浪费内存，有可能出现吃了资源没输出。

接下来看一段代 码：

/*类中各成员初始化的顺序：
  父类的静态字段——>父类静态代码块——>
  子类静态字段——>子类静态代码块——>
  父类成员变量（非静态字段）——>父类非静态代码块——>父类构造器——>
  子类成员变量——>子类非静态代码块——>子类构造器
*/
public class HungrySingleton { 

private static final HungrySingleton hungrySingleton = new HungrySingleton(); 

    private HungrySingleton(){} 
    
    public static HungrySingleton getInstance(){ 
    return hungrySingleton; 
  } 
}

另外一种写法，静态代码块单例：

public class HungryStaticSingleton { 

  private static final HungryStaticSingleton hungrySingleton; 
  
  static { 
       hungrySingleton = new HungryStaticSingleton(); 
  }
  
  private HungryStaticSingleton(){} 
  
  public static HungryStaticSingleton getInstance(){ 
       return hungrySingleton; 
  } 
}

这两种写法都非常的简单明了，也很利于理解，饿汉式单例适用在单例对象较少的情况(初始化是要花费时间的)。接下来我们来探讨一下性能更优的单例写法。

懒汉式单例

懒汉式单例特点：被外部类调用的时候内部类才会加载，下面是懒汉式单例的简单实现 LazySimpleSingleton：

public class LazySimpleSingleton { 
   private LazySimpleSingleton(){} 
   
   private static LazySimpleSingleton lazySimpleSingleton = null; 
   
   public static LazySimpleSingleton getInstance(){ 
      if(lazySimpleSingleton == null){ 
         lazySimpleSingleton = new LazySimpleSingleton(); 
      }
      return lazySimpleSingleton; 
   } 
}

这种写法有没有问题呢，我们来做一个测试，创建一个线程类 ExectorThread：

public class ExectorThread implements Runnable{ 
   @Override 
   public void run() { 
      LazySimpleSingleton singleton = LazySimpleSingleton.getInstance();          
      System.out.println(Thread.currentThread().getName() + ":" + singleton); 
   } 
}

编写测试代码：

public class LazySimpleSingletonTest { public static void main(String[] args) { 
   Thread t1 = new Thread(new ExectorThread()); 
   Thread t2 = new Thread(new ExectorThread()); 
   t1.start(); 
   t2.start(); 
   System.out.println("TheEnd"); 
 } 
}

经过多次折腾之后发现有一定概率出现创建两个不同对象的情况，意味着上面的生成单例方式在多线程情况下会存在安全隐患。

可自行利用IntelliJ IDEA - Debug 线程模式调试调试上述代码。

如何解决多线程下的安全问题，尝试给 getInstance()加 上 synchronized 关键字，这样这个方法变成线程同步方法，代码如下：

public class LazySimpleSingleton { 

   private LazySimpleSingleton(){} 
   
   private static LazySimpleSingleton lazySimpleSingleton = null; 
   
   public synchronized static LazySimpleSingleton getInstance(){    
      if(lazySimpleSingleton == null){ 
         lazySimpleSingleton = new LazySimpleSingleton(); 
      }
      return lazySimpleSingleton; 
  } 
}

这时候，我们再次调试新代码。当我们将其中一个线程执行并调用getInstance()方法时，另一 个线程同时也来调用 getInstance()方法，线程的状态由RUNNING变成了MONITOR,出现阻 塞。直到第一个线程执行完，第二个线程才恢复RUNNING状态继续调用getInstance()方法。这个示例代码完美的展现了synchronized 监视锁的运行状态，线程安全的问题得到了解决了。但是众所周知用 synchronized 加锁，在线程数量比较多竞争激烈的情况下，如果CPU分配压力上升，会导致大批量线程出现阻塞，从而导致程序运行性能大幅下降。那么，有没有一种更好的方式，既兼顾线程安全又提升程序性能。我们来看双重检查锁的单例模式，代码如下：

public class LazyDoubleCheckSingleton { 
   private volatile static LazyDoubleCheckSingleton lazyDoubleCheckSingleton = null; 
   
   private LazyDoubleCheckSingleton(){} 
   
   public static LazyDoubleCheckSingleton getInstance(){ 
      if(lazyDoubleCheckSingleton == null){ 
        synchronized (LazyDoubleCheckSingleton.class){ 
         if(lazyDoubleCheckSingleton == null){ 
            lazyDoubleCheckSingleton = new LazyDoubleCheckSingleton(); 
         } 
      } 
   }
   return lazyDoubleCheckSingleton; 
 } 
}

当第一个线程调用getInstance()方法时，第二个线程也可以调用getInstance()。当第一 个线程执行到synchronized时会上锁，第二个线程就会变成MONITOR状态，出现阻塞。此时，阻塞并不是基于整个 LazySimpleSingleton类的阻塞，而是在getInstance()方法内部阻塞，只要逻辑不是太复杂，对于调用者而言感知不到。 但是，用到synchronized关键字，总归是要上锁，对程序性能还是存在一定影响的。难道就真的没有更好的方案吗？当然是有的。我们可以从类初始化角度来考虑，看下面的代码，采用静态内部类的方式：

//这种形式兼顾饿汉式的内存浪费，也兼顾synchronized性能问题、完美地屏蔽了这两个缺点 
public class LazyInnerClassSingleton { 
   //默认使用 LazyInnerClassGeneral 的时候，会先初始化内部类、如果没使用的话，内部类是不加载的 
   private LazyInnerClassSingleton(){} 
   //每一个关键字都不是多余的、static是为了使单例的空间共享、保证这个方法不会被重写，重载 
   public static final LazyInnerClassSingleton getInstance(){ 
      //在返回结果以前，一定会先加载内部类 
      return LazyHolder.LAZY; 
   }
   //默认不加载 
   private static class LazyHolder{ 
      private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton(); 
   } 
}

这种形式兼顾饿汉式的内存浪费，也兼顾 synchronized 性能问题。内部类一定是要在方 法调用之前初始化，巧妙地避免了线程安全问题。

到此为止你是否觉得你已经掌握了单例模式，其实这才只是一个开始接下来我们继续深入探讨

反射破坏单例

大家应该发现了上面介绍的单例模式的构造方法除了加上private以外，没有做任何其他处理。如果我们使用反射来调用其构造方法，然后，再调用 getInstance()方法，应该就会两个不同的实例。现在来然我们编写一段测试代码验证一下这个问题，以 LazyInnerClassSingleton 为例：

public class LazyInnerClassSingletonTest { 
	public static void main(String[] args) { 
		try{
			//总会有无聊的人会进行破坏 
			Class<?> clazz = LazyInnerClassSingleton.class; 
			//通过反射拿到私有的构造方法 
			Constructor c = clazz.getDeclaredConstructor(null); 
			//强制访问 
			c.setAccessible(true); 
			//暴力初始化 
			Object o1 = c.newInstance(); 
			//调用了两次构造方法，相当于 new 了两次、犯了原则性问题
			Object o2 = c.newInstance(); 
			System.out.println(o1 == o2); 
		}catch (Exception e){ 
			e.printStackTrace(); 
		} 
	} 
}

显然得到的结果是false，是创建了两个不同的实例。看到这里心态是不是崩了，没关系接下来有办法解决，让我们在其构造方法中做一些限制，一旦出现多次重复创建的情况，直接抛出异常。来编写处理后的代码：

public class LazyInnerClassSingleton { 
	//默认使用LazyInnerClassGeneral的时候，会先初始化内部类,如果没使用的话，内部类是不加载的 
	private LazyInnerClassSingleton(){ 
		if(LazyHolder.LAZY != null){ 
			throw new RuntimeException("不允许创建多个实例"); 
		} 
	}
	//每一个关键字都不是多余的,static 是为了使单例的空间共享,保证这个方法不会被重写，重载 
	public static final LazyInnerClassSingleton getInstance(){ 
		//在返回结果以前，一定会先加载内部类 
		return LazyHolder.LAZY; 
	}
	//默认不加载 
	private static class LazyHolder{ 
		private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton(); 
	}
}

再次运行之前的测试代码，会得到不允许创建多个实例的报错提示，至此想通过反射干坏事的人已经无计可施。但是他们总是孜孜不倦的想出新的花样，接下来继续看下去。

序列化破坏单例

当我们将一个单例对象创建好，有时候需要将对象序列化然后写入到磁盘，以后再次使用时再从磁盘中读取到对象，反序列化转化为内存对象。反序列化后的对象会重新分配内存，即重新创建。那如果序列化的目标的对象为单例对象，那就违背了单例模式的初衷，相当于破坏了单例模式，接下来让我们用一段代码来验证，单例代码：

//反序列化时导致单例破坏 
public class SeriableSingleton implements Serializable { 
	//序列化就是说把内存中的状态通过转换成字节码的形式 
	//从而转换一个 IO 流，写入到其他地方(可以是磁盘、网络 IO) 
	//内存中状态给永久保存下来了 
	//反序列化 
	//讲已经持久化的字节码内容，转换为 IO 流 
	//通过 IO 流的读取，进而将读取的内容转换为 Java 对象 
	//在转换过程中会重新创建对象 new 
	public final static SeriableSingleton INSTANCE = new SeriableSingleton(); 
	private SeriableSingleton(){} 
	public static SeriableSingleton getInstance(){ 
		return INSTANCE; 
	} 
}

测试代码：

public class SeriableSingletonTest { 
	public static void main(String[] args) { 
		SeriableSingleton s1 = null; 
		SeriableSingleton s2 = SeriableSingleton.getInstance(); 
		FileOutputStream fos = null; 
		try {
			fos = new FileOutputStream("SeriableSingleton.obj"); 
			ObjectOutputStream oos = new ObjectOutputStream(fos); 
			oos.writeObject(s2); 
			oos.flush(); 
			oos.close(); 
			FileInputStream fis = new FileInputStream("SeriableSingleton.obj"); 
			ObjectInputStream ois = new ObjectInputStream(fis); 
			s1 = (SeriableSingleton)ois.readObject(); 
			ois.close(); 
			
			System.out.println(s1); 
			System.out.println(s2); 
			System.out.println(s1 == s2); 
		} catch (Exception e) { 
			e.printStackTrace(); 
		} 
	} 
}

很显然从运行结果中可以看出反序列化后的对象和手动创建的对象是不一致的，实例化了两次，违背了单例的设计初衷。那么，如何保证序列化的情况下也能够实现单例。其实很简单，只需要增加readResolve()方法即可。接下来编写代码：

public class SeriableSingleton implements Serializable { 
	public final static SeriableSingleton INSTANCE = new SeriableSingleton(); 
	private SeriableSingleton(){} 
	public static SeriableSingleton getInstance(){ 
		return INSTANCE; 
	}
	private Object readResolve(){ 
		return INSTANCE; 
	} 
}

再次运行测试代码发现真的解决了破坏单例的情况。

大家一定想刨根问底这到底是为啥这样写一下就好了，看上去有些神奇样子，当然也让人感到些费解 。 不 如让我们一起来深入JDK的源码实现就一清二楚了 。 我们进入ObjectInputStream类的readObject()方法，代码如下：

public final Object readObject() throws IOException, ClassNotFoundException { 
	if (enableOverride) { 
		return readObjectOverride(); 
	}
	// if nested read, passHandle contains handle of enclosing object 
	int outerHandle = passHandle; 
	try {
		Object obj = readObject0(false); 
		handles.markDependency(outerHandle, passHandle); 
		ClassNotFoundException ex = handles.lookupException(passHandle); 
		if (ex != null) { 
			throw ex; 
		}
		if (depth == 0) { 
			vlist.doCallbacks(); 
		}
		return obj; 
	} finally { 
		passHandle = outerHandle; 
		if (closed && depth == 0) { 
			clear(); 
		} 
	} 
}

我们发现在readObject中又调用了我们重写的readObject0()方法。进入readObject0() 方法，代码如下：

private Object readObject0(boolean unshared) throws IOException { 
	... 
	case TC_OBJECT: return checkResolve(readOrdinaryObject(unshared)); 
	... 
}

我们看到 TC_OBJECTD 中判断，调用了 ObjectInputStream 的 readOrdinaryObject() 方法，我们继续进入看源码：

private Object readOrdinaryObject(boolean unshared) throws IOException { 
	if (bin.readByte() != TC_OBJECT) { 
		throw new InternalError(); 
	}
	ObjectStreamClass desc = readClassDesc(false); 
	desc.checkDeserialize(); 
	Class<?> cl = desc.forClass(); 
	if (cl == String.class || cl == Class.class || cl == ObjectStreamClass.class) { 
		throw new InvalidClassException("invalid class descriptor"); 
	}
	Object obj; 
	try {
		obj = desc.isInstantiable() ? desc.newInstance() : null; 
	} catch (Exception ex) { 
		throw (IOException) new InvalidClassException( desc.forClass().getName(), "unable to create instance").initCause(ex); 
	}
	
	... 
	
	return obj; 
}

发现调用了ObjectStreamClass的isInstantiable()方法，而isInstantiable()里面的代码 如下：

boolean isInstantiable() { 
	requireInitialized(); 
	return (cons != null); 
}

代码非常简单，就是判断一下构造方法是否为空，构造方法不为空就返回 true。意味着，只要有无参构造方法就会实例化。 这时候，其实还没有找到为什么加上 readResolve()方法就避免了单例被破坏的真正原 因。我再回到ObjectInputStream的readOrdinaryObject()方法继续往下看：

private Object readOrdinaryObject(boolean unshared) throws IOException { 
	if (bin.readByte() != TC_OBJECT) { 
		throw new InternalError(); 
	}
	ObjectStreamClass desc = readClassDesc(false); 
	desc.checkDeserialize(); 
	Class<?> cl = desc.forClass(); 
	if (cl == String.class || cl == Class.class || cl == ObjectStreamClass.class) { 
		throw new InvalidClassException("invalid class descriptor"); 
	}
	Object obj; 
	try {
		obj = desc.isInstantiable() ? desc.newInstance() : null; 
	} catch (Exception ex) { 
		throw (IOException) new InvalidClassException( desc.forClass().getName(), "unable to create instance").initCause(ex); 
	}
	
	、、、
	
	if (obj != null && handles.lookupException(passHandle) == null && desc.hasReadResolveMethod()) { 
	Object rep = desc.invokeReadResolve(obj); 
	if (unshared && rep.getClass().isArray()) { 
		rep = cloneArray(rep); 
	}
		if (rep != obj) { 
		// Filter the replacement object 
		if (rep != null) { 
			if(rep.getClass().isArray()) { 
				filterCheck(rep.getClass(), Array.getLength(rep)); 
			} else {
				 filterCheck(rep.getClass(), -1); 
			 } 
		 }
		 handles.setObject(passHandle, obj = rep); 
		 } 
	 }
	 return obj; 
 }

判断无参构造方法是否存在之后，又调用了 hasReadResolveMethod()方法，来看代码：

boolean hasReadResolveMethod() { 
	requireInitialized(); 
	return (readResolveMethod != null); 
}

逻辑非常简单，就是判断 readResolveMethod 是否为空，不为空就返回 true。那么 readResolveMethod 是在哪里赋值的呢？通过全局查找找到了赋值代码在私有方法 ObjectStreamClass()方法中给 readResolveMethod 进行赋值，来看代码：

readResolveMethod = getInheritableMethod( cl, "readResolve", null, Object.class);

上面的逻辑其实就是通过反射找到一个无参的 readResolve()方法，并且保存下来。现在 再 回 到 ObjectInputStream 的 readOrdinaryObject() 方 法 继 续 往 下 看 ， 如 果 readResolve()存在则调用 invokeReadResolve()方法，来看代码：

	Object invokeReadResolve(Object obj) throws IOException, UnsupportedOperationException { requireInitialized(); 
	if (readResolveMethod != null) { 
		try {
		return readResolveMethod.invoke(obj, (Object[]) null); 
		} catch (InvocationTargetException ex) { 
			Throwable th = ex.getTargetException(); 
			if (th instanceof ObjectStreamException) { 
				throw (ObjectStreamException) th; 
			} else { 
				throwMiscException(th); 
				throw new InternalError(th); // never reached 
			} 
		} catch (IllegalAccessException ex) { 
			// should not occur, as access checks have been suppressed 
			throw new InternalError(ex); 
		} 
	} else { 
		throw new UnsupportedOperationException(); 
	} 
}

我们可以看到在 invokeReadResolve()方法中用反射调用了 readResolveMethod 方法。 通过 JDK 源码分析我们可以看出，虽然，增加 readResolve()方法返回实例，解决了单 例被破坏的问题。但是，我们通过分析源码以及调试，我们可以看到实际上实例化了两 次，只不过新创建的对象没有被返回而已。那如果，创建对象的动作发生频率增大，就 意味着内存分配开销也就随之增大，难道真的就没办法从根本上解决问题吗？下面我们 来注册式单例也许能帮助到你。

注册式单例

注册式单例又称为登记式单例，就是将每一个实例都登记到某一个地方，使用唯一的标 识获取实例。注册式单例有两种写法：一种为容器缓存，一种为枚举登记。先来看枚举 式单例的写法，来看代码，创建 EnumSingleton 类：

public enum EnumSingleton { 
	INSTANCE; 
	private Object data; 
	public Object getData() { 
		return data; 
	}
	public void setData(Object data) { 
		this.data = data; 
	}
	public static EnumSingleton getInstance(){ 
		return INSTANCE; 
	} 
}

编写测试代码：

public class EnumSingletonTest { 
	public static void main(String[] args) { 
		try {
			EnumSingleton instance1 = null; 
			EnumSingleton instance2 = EnumSingleton.getInstance(); 
			instance2.setData(new Object()); 
			FileOutputStream fos = new FileOutputStream("EnumSingleton.obj"); 
			ObjectOutputStream oos = new ObjectOutputStream(fos); 
			oos.writeObject(instance2); 
			oos.flush(); 
			oos.close(); 
			FileInputStream fis = new FileInputStream("EnumSingleton.obj"); 
			ObjectInputStream ois = new ObjectInputStream(fis); 
			instance1 = (EnumSingleton) ois.readObject(); 
			ois.close(); 
			System.out.println(instance1.getData()); 
			System.out.println(instance2.getData()); 
			System.out.println(instance1.getData() == instance2.getData()); 
		}catch (Exception e){ 
			e.printStackTrace(); 
		} 
	} 
}

奇怪吧，没有做任何处理，我们发现运行结果和我们预期的一样，序列化反序列化并没有破坏单例。那么枚举式单例为何如此神奇，下面我们通过分析源码来直击它的本质。

首先，下载一个 Java 反编译工具 Jad（下载地址：https://varaneckas.com/jad/）， 解压后配置好环境变量（自行查阅如何配置），就可以使用命令行调用了。找到工程所在的class目录，复制EnumSingleton.class所在的路径。然后切回到命令行，切换到工程所在的 Class 目录，输入命令 jad 后面输入复制好的路 径，我们会在 Class 目录下会多一个 EnumSingleton.jad 文件。打开 EnumSingleton.jad 文件我们惊奇又巧妙地发现有如下代码：

static { 
	INSTANCE = new EnumSingleton("INSTANCE", 0); 
	$VALUES = (new EnumSingleton[] { 
		INSTANCE 
	}); 
}

至此，发现枚举式单例在静态代码块中就给 INSTANCE 进行了赋值，是饿汉式单例的实现。 最后，我们还可以试想，通过序列化我们不能破坏枚举式单例。让我们再次回到 JDK 源码，进入到 ObjectInputStream 的 readObject0()方法：

private Object readObject0(boolean unshared) throws IOException { 

	... 
	
	case TC_ENUM: return checkResolve(readEnum(unshared));
	
	... 

}

从此可以知道在readObject0()中调用了readEnum()方法，接下来看readEnum()中代码实现：

private Enum<?> readEnum(boolean unshared) throws IOException { 
	if (bin.readByte() != TC_ENUM) { 
		throw new InternalError(); 
	}
	ObjectStreamClass desc = readClassDesc(false); 
	if (!desc.isEnum()) { 
		throw new InvalidClassException("non-enum class: " + desc); 
	}
	int enumHandle = handles.assign(unshared ? unsharedMarker : null); 
	ClassNotFoundException resolveEx = desc.getResolveException(); 
	if (resolveEx != null) { 
		handles.markException(enumHandle, resolveEx); 
	}
	String name = readString(false); 
	Enum<?> result = null; Class<?> cl = desc.forClass(); 
	if (cl != null) { 
		try { 
			@SuppressWarnings("unchecked") 
			Enum<?> en = Enum.valueOf((Class)cl, name); 
			result = en; 
		} catch (IllegalArgumentException ex) { 
			throw (IOException) new InvalidObjectException( "enum constant " + name + " does not exist in " + cl).initCause(ex); 
		}if (!unshared) { 
			handles.setObject(enumHandle, result); 
		} 
	}
	handles.finish(enumHandle); 
	passHandle = enumHandle; 
	return result; 
}

最终，我们发现枚举类型其实通过类名和Class对象类找到一个唯一的枚举对象。因此，枚举对 象不可能被类加载器加载多次。那么反射是否能破坏枚举式单例，让我们用一段代码测试一下：

public static void main(String[] args) { 
	try {
		Class clazz = EnumSingleton.class; 
		Constructor c = clazz.getDeclaredConstructor(); 
		c.newInstance(); 
	}catch (Exception e){ 
		e.printStackTrace(); 
	} 
}

运行结果报的是java.lang.NoSuchMethodException异常，意思是没找到无参的构造方法。这个报错有些莫名其妙，那么我们再打开java.lang.Enum 的源码代码，来查看一下它的构造方法，发现只有一个protected的构造方法，代码如下：

protected Enum(String name, int ordinal) { 
	this.name = name; 
	this.ordinal = ordinal; 
}

再写一段类似得我测试代码：

public static void main(String[] args) { 
	try {
		Class clazz = EnumSingleton.class; 
		Constructor c = clazz.getDeclaredConstructor(String.class,int.class); 
		c.setAccessible(true); 
		EnumSingleton enumSingleton = (EnumSingleton)c.newInstance("Ma",999); 
	}catch (Exception e){ 
		e.printStackTrace(); 
	} 
}

看这次的运行结果，这时错误已经非常明显了，告诉我们Cannot reflectively create enum objects，不能用反射来创建枚举类型。还是得回过头来看看JDK源码，进入Constructor的 newInstance()方法：

public T newInstance(Object ... initargs) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException { 
	if (!override) { 
		if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) { 
			Class<?> caller = Reflection.getCallerClass(); 
			checkAccess(caller, clazz, null, modifiers); 
		} 
	} 
	 if ((clazz.getModifiers() & Modifier.ENUM) != 0) throw new IllegalArgumentException("Cannot reflectively create enum objects"); 
	 ConstructorAccessor ca = constructorAccessor; 
	 // read volatile 
	 if (ca == null) { 
	 	ca = acquireConstructorAccessor(); 
	 }
	 @SuppressWarnings("unchecked") 
	 T inst = (T) ca.newInstance(initargs); 
	 return inst; 
 }

可以看见在 newInstance()方法中做了强制性的判断，如果修饰符是 Modifier.ENUM 枚举类型，直接抛出异常。到这为止，我们是不是已经非常清晰明了。枚举式单例也是《Effective Java》一书中推荐的一种单例实现写法。在JDK枚举的语法特殊性，以及反射也为枚举保驾护航，让枚举式单例成为一种比较优雅的实现。 接下来看注册式单例还有另一种写法，容器缓存的写法，接下来创建ContainerSingleton 类：

public class ContainerSingleton { 
	private ContainerSingleton(){} 
	private static Map<String,Object> ioc = new ConcurrentHashMap<String,Object>(); 
	public static Object getBean(String className){ 
		synchronized (ioc) { 
			if (!ioc.containsKey(className)) { 
				Object obj = null; 
				try {
					obj = Class.forName(className).newInstance(); 
					ioc.put(className, obj); 
				} catch (Exception e) { 
					e.printStackTrace(); 
				}
				return obj; 
			} else { 
				return ioc.get(className); 
			} 
		} 
	} 
}

容器式写法适用于创建实例非常多的情况，便于管理。但是，是非线程安全的。到此， 注册式单例介绍完毕。
我们再来看看 Spring 中的容器式单例的实现代码：

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory { 
	/** Cache of unfinished FactoryBean instances: FactoryBean name --> BeanWrapper */ 
	private final Map<String, BeanWrapper> factoryBeanInstanceCache = new ConcurrentHashMap<>(16); 
	
	... 

}

ThreadLocal 线程单例

最后给大家讲一个，线程单例实现ThreadLocal。ThreadLocal不能保证其创建的对象是全局唯一，但是能保证在单个线程中是唯一的，天生的线程安全。下面我 们来看代码：

public class ThreadLocalSingleton { 
	private static final ThreadLocal<ThreadLocalSingleton> threadLocalInstance = new ThreadLocal<ThreadLocalSingleton>(){ 
		@Override 
		protected ThreadLocalSingleton initialValue() { 
			return new ThreadLocalSingleton(); 
		} 
	}; 
	private ThreadLocalSingleton(){} 
	public static ThreadLocalSingleton getInstance(){ 
		return threadLocalInstance.get(); 
	} 
}

编写一下测试代码：

public static void main(String[] args) { 
	System.out.println(ThreadLocalSingleton.getInstance()); 
	System.out.println(ThreadLocalSingleton.getInstance()); 
	System.out.println(ThreadLocalSingleton.getInstance()); 
	System.out.println(ThreadLocalSingleton.getInstance()); 
	System.out.println(ThreadLocalSingleton.getInstance()); 
	
	Thread t1 = new Thread(new ExectorThread()); 
	Thread t2 = new Thread(new ExectorThread()); 
	t1.start(); 
	t2.start(); System.out.println("End"); 
}

从运行结果中可以发现，在主线程main中无论调用多少次，获取到的实例都是同一个，但在两个子线程中分别获取到了不同的实例。那么ThreadLocal是如果实现这样的效果的。我们知道上面的单例模式为了达到线程安全的目的，给方法上锁，以时间换空间。ThreadLocal将所有的对象全部放在ThreadLocalMap中，为每个线程都提供一个对象，实际上是以空间换时间来实现线程间隔离的。

单例模式总结

单例模式可以保证内存里只有一个实例，从而减少了内存开销；可以避免对资源的多重占用。 单例模式看起来非常简单，实现起来也非常简单。希望各位同学通过本文章的阅读理解，对单例模式有非常深刻的掌握。