23种设计模式之单例模式
核心作用：
保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。
常见应用场景：
—— Windows的Task Manager（任务管理器）就是很典型的单例模式。
—— Windows的Recycle Bin（回收站）也是典型的单例应用。在整个运行过程中，回收站一直维护着仅有的一个实例。
—— 项目中，读取配置文件的类，一般也只有一个对象，没有必要每次使用配置文件的数据，每次new一个对象去读取。
—— 网站的计数器，一般也是采用单例模式实现的，否则难以同步。
—— 应用程序的日志应用，一般都是用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。
—— 数据库连接池的设计一般也是采用单例模式，因为数据库的连接是一种数据库资源。
—— 操作系统的文件系统，也是大的单例模式实现的具体例子，一个操作系统只能有一个文件系统。
—— Application也是单例的典型应用（Servlet编程中会涉及到）。
—— 在Spring中，每个Bean默认就是单例的。这样做的优点是spring容器可以管理。
—— 在servlet编程中，每个Servlet也是单例。
—— 在spring MVC框架/struts1框架中，控制器对象也是单例。
单例模式的优点：
1、由于单例模式只生成一个实例，减少了系统性能开销。当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个实例对象（避免对资源的多重占用）。然后永久驻留内存的方式来解决（减少内存开支）。
2、单例模式可以在系统设置全局的访问点，优化和共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理。
单例模式的缺点：
1、单例模式一般没有接口，扩展很困难。若要扩展，除了修改代码基本上没有第二种途径可以实现。
2、单例模式对测试是不利的。在并行开发环境中，如果单例模式没有完成，是不能进行测试的，没有接口也不能使用mock的方式虚拟一个对象。
3、单例模式与单一职责原则有冲突。
常见的五种单例模式实现方法：
主要：
饿汉式（线程安全，调用效率高。不能延迟加载。）
懒汉式（线程安全，调用效率低。可以延迟加载。）
其他：
双重检测锁式（由于JVM底层内部模型原因，偶尔会出问题，不建议使用）
静态内部类式（线程安全，调用效率高。可以延迟加载。）
枚举单例（线程安全，调用效率高。不能延迟加载。并且可以天然的防止反射和反序列化漏洞）
饿汉式（单例对象立即加载）：
public class SingletonDemo1 {
private static SingletonDemo1 singletonDemo1=new SingletonDemo1();
private SingletonDemo1(){
}
public static SingletonDemo1 getInstance(){
return singletonDemo1;
}
}饿汉式单例模式代码中，static变量会在类装载时初始化，此时也不会涉及多个线程对象访问该对象的问题。虚拟机保证只会装载一次该类，肯定不会发生访问的问题。
缺点：如果只是加载本类，而不是调用getInstance()，甚至永远没有调用，会造成资源的浪费。
懒汉式（单例对象延迟加载）：
public class SingletonDemo2 {
private static SingletonDemo2 singletonDemo2;
private SingletonDemo2(){
}
public static synchronized SingletonDemo2 getInstance(){
if(singletonDemo2==null){
singletonDemo2=new SingletonDemo2();
}
return singletonDemo2;
}
}用的时候才加载。
缺点：资源利用率高了，但是，每次调用getInstance()方法都要同步，并发效率低。
双重检测锁式：
public class SingletonDemo3 {
private static SingletonDemo3 singletonDemo3=null;
private SingletonDemo3(){
}
public static SingletonDemo3 getInstance(){
if(singletonDemo3==null){
SingletonDemo3 sd;
synchronized (SingletonDemo3.class) {
sd=singletonDemo3;
if(sd==null){
synchronized (SingletonDemo3.class) {
if(sd==null){
sd=new SingletonDemo3();
}
}
singletonDemo3=sd;
}
}
}
return singletonDemo3;
}
}这个模式将同步内容下方到if内部，提高了执行的效率，不必每次获取对象时都进行同步，只有第一次才同步创建了以后就没必要了。
缺点：由于编译器优化原因和JVM底层内部模型原因，偶尔会出问题。不建议使用。
静态内部类式：
public class SingletonDemo4 {
private static class SingletonClassInstance{
private static final SingletonDemo4 SINGLETON_DEMO4=new SingletonDemo4();
}
private SingletonDemo4(){
}
public static SingletonDemo4 getInstance(){
return SingletonClassInstance.SINGLETON_DEMO4;
}
}要点：
1、外部类没有static属性，则不会像饿汉式那样立即加载对象；
2、只有真正调用getInstance()，才会加载静态内部类。加载类时是线程安全的。SINGLETON_DEMO4是static final类型的，保证了内存中只有这样一个实例存在，而且只能被赋值一次，从而保证了线程安全；
3、兼备了并发高效调用和延迟加载的优势。
枚举单例：
public enum SingletonDemo5 {
/**
* 定义一个枚举的元素，它就代表了Singleton的一个实例
*/
INSTANCE;
/**
* 单例可以有自己的操作
*/
public void singletonOperation(){
}
}优点：1、实现简单。2、枚举本身就是单例模式。由JVM从根本上提供保障！避免通过反射和反序列化的漏洞！
缺点：无延迟加载。
如何选用？
—— 单例对象 占用资源少，不需要延迟加载：枚举式 好于 饿汉式
—— 单例对象 占用资源大，需要延迟加载：静态内部类式 好于 懒汉式
常见的五种单例模式在多线程环境下的效率测试
关注相对值即可。在不同的环境下不同的程序测的值完全不一样。
CountDownLatch：
同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。
countDown()：当前线程调此方法，则计数减一（建议放在finally里执行）
await()：调用此方法会一直阻塞当前线程，直到计数器的值为0
测试：
public class Test2 {
public static void main(String[] args) throws Exception{
long start=System.currentTimeMillis();
int threadNum=10;
final CountDownLatch countDownLatch=new CountDownLatch(threadNum);
for(int i=0;i测试结果：
| 饿汉式 | 12ms |
| 懒汉式 | 8918ms |
| 双重检测锁式 | 12ms |
| 静态内部类式 | 112ms |
| 枚举式 | 38ms |
问题
—— 反射可以破解上面几种（不含枚举式）实现方式！（可以在构造方法中手动抛出异常控制）
public static void main(String[] args) throws Exception {
SingletonDemo6 demo1=SingletonDemo6.getInstance();
SingletonDemo6 demo2=SingletonDemo6.getInstance();
System.out.println(demo1);
System.out.println(demo2);
//通过反射的方式直接调用私有构造器
Class clazz=(Class) Class.forName("com.singleton.demo.SingletonDemo6");
Constructor c=clazz.getDeclaredConstructor(null);
c.setAccessible(true);
SingletonDemo6 demo3=c.newInstance();
SingletonDemo6 demo4=c.newInstance();
System.out.println(demo3);
System.out.println(demo4);
} 输出结果：
com.singleton.demo.SingletonDemo6@15db9742
com.singleton.demo.SingletonDemo6@15db9742
com.singleton.demo.SingletonDemo6@6d06d69c
com.singleton.demo.SingletonDemo6@7852e922
破解方法：
在构造方法中手动抛出异常控制：
private SingletonDemo6() throws Exception{
//通过手动抛出异常，避免通过反射创建多个单例对象
if(singletonDemo6!=null){
throw new Exception("只能创建一个对象");
}
}输出结果（抛出异常）：
com.singleton.demo.SingletonDemo6@15db9742
com.singleton.demo.SingletonDemo6@15db9742
Exception in thread "main" java.lang.reflect.InvocationTargetException
at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
at sun.reflect.NativeConstructorAccessorImpl.newInstance(Unknown Source)
at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(Unknown Source)
at java.lang.reflect.Constructor.newInstance(Unknown Source)
at com.singleton.demo.Test3.main(Test3.java:17)
Caused by: java.lang.Exception: 只能创建一个对象
at com.singleton.demo.SingletonDemo6.
... 5 more
—— 反序列化可以破解上面几种（不含枚举式）实现方式！（可以通过定义readResolve()防止获得不同对象。）反序列化时，如果对象所在类定义了readResolve()，（实际是一种回调），定义返回那个对象。
public static void main(String[] args) throws Exception {
SingletonDemo6 demo1=SingletonDemo6.getInstance();
SingletonDemo6 demo2=SingletonDemo6.getInstance();
System.out.println(demo1);
System.out.println(demo2);
//通过反序列化的方式构造多个对象
FileOutputStream fos=new FileOutputStream("d:/a.txt");
ObjectOutputStream oos=new ObjectOutputStream(fos);
oos.writeObject(demo1);
oos.close();
fos.close();
ObjectInputStream ois=new ObjectInputStream(new FileInputStream("d:/a.txt"));
SingletonDemo6 demo3=(SingletonDemo6) ois.readObject();
System.out.println(demo3);
}注意：需要在SingletonDemo6实现Serializable反序列化接口
public class SingletonDemo6 implements Serializable{
输出结果：
com.singleton.demo.SingletonDemo6@15db9742
com.singleton.demo.SingletonDemo6@15db9742
com.singleton.demo.SingletonDemo6@e9e54c2
破解方法：
在SingletonDemo6中定义readResolve()方法：
//反序列化时，如果对象所在类定义了readResolve()，（实际是一个回调），定义返回那个对象
private Object readResolve() throws ObjectStreamException{
return singletonDemo6;
}输出结果：
com.singleton.demo.SingletonDemo6@15db9742
com.singleton.demo.SingletonDemo6@15db9742
com.singleton.demo.SingletonDemo6@15db9742
下一节 23种设计模式之工厂模式