创建型--单例设计模式(Singleton pattern)

单例模式

• 核心作用：
  • 保证一个类只有一个实例，并且提供一个访问该实例的全局访问点
• 常见应用场景
  • Windows的Task Manager（任务管理器）就是很典型的单例模式
  • Windows的Recycle Bin（回收站）也是典型的单例应用。在整个系统运行过程中，回收站一直维护者仅有的一个实例
  • 项目中，读取配置文件的类，一般也只有一个对象。没有必要每次使用配置文件数据，每次new一个对象去读取
  • 网站的计数器，一般也是采用单例模式实现的，否则难以同步
  • 应用程序的日志应用，一般都用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加
  • 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源
  • 操作系统的文件系统，也是大的单例模式实现的具体例子，一个操作系统只能有一个文件系统
  • Application 也是单例的典型应用（Servlet编程中会涉及到）
  • 在Spring中，每个Bean默认就是单例的，这样做的优点是Spring容器可以管理
  • 在Servlet编程中，每个Servlet也是单例
  • 在Spring MVC框架/struts1框架中，控制器对象也是单例
• 单例模式的优点
  • 由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永远驻留内存的方式来解决
  • 单例模式可以在系统设置全局的访问点，优化环共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理

常见的五种单例模式实现方式

• 主要
  • 饿汉式（线程安全，调用效率高。不能延迟加载）
  • 懒汉式（线程安全，调用效率不高，可以延迟加载）
• 其他
  • 双重检测锁式（由于JVM底层内部模型原因，偶尔会出问题，不建议使用）
  • 静态内部类式（线程安全，调用效率高可以延迟加载）
  • 枚举单例（线程安全，调用效率高，不能延迟加载）
• 如何选择
  • 单例对象，占用资源少，不需要延迟加载
    • 枚举式 好于 饿汉式
  • 单例对象，占用资源大，需要延迟加载
    • 静态内部类式 好于 懒汉式

饿汉式(单例对象立即加载)

• 饿汉式单例模式代码中，static变量会在类装载时初始化，此时也不会涉及多个线程对象访问该对象的问题。虚拟机保证只会装载一次该类，肯定不会发生并发访问的问题。因此，可以省略synchronized关键字
• 问题：如果只是加载本类，而不是要调用getInstance()，甚至永远没有调用，则会造成资源浪费
• 代码例子：

package testsingleton;
//singleton---单例

/**
 * 测试饿汉式单例模式
 */
 public class SingletonDemo01 {
 
	//类初始化时，立即加载这个对象（没有延迟加载的优势）。加载类时，天然的是线程安全的
	private static SingletonDemo01 instance = new SingletonDemo01();
	
	private SingletonDemo01() {//私有化构造器
		
	}
	
	//方法没有同步，调用效率高，
	public static SingletonDemo01 getInstance() {
		return instance;
	}
}

懒汉式(单例对象延迟加载)

• 要点：
• • lazy load！(延迟加载，懒加载)，真正用的时候才加载
• 问题：
• • 资源利用率高了，但是，每次调用getInstance()方法都要同步，并发效率较低
• 代码例子：

package testsingleton;

/**
 * 测试懒汉式单例模式
 * @author 橙汁儿Drk
 *
 */
public class SingletonDemo2 {

	//类初始化时，不初始化这个对象（延迟加载，真正用的时候再创建）。
	private static SingletonDemo2 instance;
	
	private SingletonDemo2() {//私有化构造器
		
	}
	
	//方法同步，调用效率低。
	public static synchronized SingletonDemo2 getInstance() {
		if (instance == null) {
			instance = new SingletonDemo2();
		}
		return instance;
	}
}

双重检测锁模式

• 这个模式将同步内容下放到if内部，提高了执行的效率，不必每次获取对象时都进行同步，只有第一次同步创建了以后就没必要了。
• 问题：
• • 单例对象要加volatile，防止指令重排

public class SingletonDemo03{
   private static volatile SingletonDemo03 instance = null;
   public static SingletonDemo03 getInstance(){
       if(instance == null){
           sychronized(SingletonDemo03.class){
               if(sc == null){
                   sc = new SingletonDemo03();
               }
           }
       }
       return instance;
   }


   private SingletonDemo03(){}
}

静态内部类实现方式（也是一种懒加载方式）

• 要点
• • 外部类没有static属性，则不会像饿汉式那样立即加载对象
  • 只有真正调用getInstance(),才会加载静态内部类。加载类时是线程安全的。instance是static final类型，保证了内存中只有这样一个实例存在，而且只能被赋值一次，从而保证了线程安全性。
  • 兼备了并发高效调用和延迟加载的优势
• 代码：

package testsingleton;

/**
 * 测试静态内部类实现单例模式
 * 这种方式线程安全，调用效率高，实现延迟加载
 * @author 橙汁儿Drk
 *
 */
public class SingletonDemo3 {

	private static class SingletonClassInstance{
		private static final SingletonDemo3 instance = new SingletonDemo3();
	}
	
	//方法同步，调用效率低。
	public static synchronized SingletonDemo3 getInstance() {
		return SingletonClassInstance.instance;
	}
	
	public SingletonDemo3() {
	}
}

枚举实现单例模式

• 优点：
• • 实现简单
  • 枚举本身就是单例模式，由JVM从根本上提供保障！避免通过反射和反序列化的漏洞！
• 缺点：
• • 无延迟加载
• 代码：

package testsingleton;

/**
 * 测试枚举实现单例模式
 * 没有延迟加载
 * 
 * @author 橙汁儿Drk
 *
 */
public enum SingletonDemo4 {
	
	//这个枚举元素，本身就是单例对象
	INSTANCE;
	
	//添加自己需要的操作
	public void singletonOperation() {
		
	}
}

• System.out.println(SingletonDemo4.INSTANCE==SingletonDemo4.INSTANCE);的结果为true

问题：

• 反射可以破解上面几种(不包括枚举式)实现方式！（可以在构造方法中手动抛出异常控制）
• 反序列化可以破解上面几种(不包括枚举式)实现方式！
• • 可以通过定义readResolve()防止获取不同的对象
• • • 反序列化时，如果对象所在的类定义了readresolve()，（实际是一种回调），定义返回哪个对象

通过反射破解懒汉式单例

package testsingleton;

import java.lang.reflect.Constructor;

/**
  * 测试反射破解单例模式
   * @author 橙汁儿Drk
*
  */
  
  public class Client2 {
  
  	public static void main(String[] args) throws Exception {
  		SingletonDemo5 s1 = SingletonDemo5.getInstance();
		SingletonDemo5 s2 = SingletonDemo5.getInstance();
		
   		System.out.println(s1);
   		System.out.println(s2);
  		
         //--------------------------------------------------------------
  		Class<SingletonDemo5> clazz = (Class<SingletonDemo5>) Class.forName("testsingleton.SingletonDemo5");
  		
  		Constructor<SingletonDemo5> c = clazz.getDeclaredConstructor(null);
  		c.setAccessible(true);//设置私有可访问权限
  		
  		SingletonDemo5 s3 = c.newInstance();
  		SingletonDemo5 s4 = c.newInstance();
  		System.out.println(s3);
   		System.out.println(s4);
  		
  	}
  }
  
  //---------------------------------
  //结果
  testsingleton.SingletonDemo5@15db9742//s1
  testsingleton.SingletonDemo5@15db9742//s2
  //发现通过反射破解了懒汉式单例，创建了两个不同的对象
  testsingleton.SingletonDemo5@6d06d69c//s3
  testsingleton.SingletonDemo5@7852e922//s4

解决办法

• 在构造器中添加if(){}语句，判断instance是否为null，不为null则抛出异常

package testsingleton;

public class SingletonDemo5 {
  
	private static SingletonDemo5 instance;
  
  	private SingletonDemo5() {
  		//通过抛出异常来阻止通过反射创建新的对象
  		if(instance != null) { throw new RuntimeException(); }
  		
  	}
  	
	public static synchronized SingletonDemo5 getInstance() {
		if (instance == null) {
   			instance = new SingletonDemo5();
   		}
  		return instance;
  	}
  }
  //反射调用构造方法时会抛出异常

通过反序列化破解懒汉式单例模式

package testsingleton;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

/**
     * 测试反射和反序列化破解单例模式
     * @author 橙汁儿Drk
  *
  */
  
  public class Client2 {

	public static void main(String[] args) throws Exception {
   		SingletonDemo5 s1 = SingletonDemo5.getInstance();
   		SingletonDemo5 s2 = SingletonDemo5.getInstance();
  		
  		System.out.println(s1);
  		System.out.println(s2);
  		
  		//通过反序列化的方式构造多个对象
  		FileOutputStream fos = new FileOutputStream("E:/MyJava/a.txt");
  		ObjectOutputStream oos = new ObjectOutputStream(fos);
  		oos.writeObject(s1);
  		oos.close();
  		fos.close();
   		
         //反序列化，读取对象
  		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("E:/MyJava/a.txt"));
  		SingletonDemo5 s3 = (SingletonDemo5) ois.readObject();
  		System.out.println(s3);
  		
  		
  	}
  }
  //结果----------------------------------------
  testsingleton.SingletonDemo5@15db9742//s1
  testsingleton.SingletonDemo5@15db9742//s2
  
  //反序列化读取对象后，发现是个新对象，破解了单例模式
  testsingleton.SingletonDemo5@4c873330//s3

解决办法

• 实现serializable,添加readResolve()方法，使得在反序列换时返回已有对象，不需要再创建新的对象

package testsingleton;

import java.io.Serializable;

/**
   * 测试懒汉式单例模式(如何防止反射和反序列化漏洞)
      * 没有延迟加载
      * 
      * @author 橙汁儿Drk
   *
   */
  public class SingletonDemo5 implements Serializable{
	
	private static SingletonDemo5 instance;
   	
   	private SingletonDemo5() {
  	}
  	
  	public static synchronized SingletonDemo5 getInstance() {
  		if (instance == null) {
  			instance = new SingletonDemo5();
  		}
  		return instance;
  	}
  	
  	//反序列化时，如果定义了readResolve()方法则直接返回此方法指定的对象。而不需要再单独创建新对象
   	private Object readResolve() {
  		return instance;
  		
  	}
  }

多线程环境下测试单例模式的效率

• 五种单例模式在多线程下相对效率比较
  | 饿汉式 | 22ms |
  | — | — |
  | 懒汉式 | 636ms |
  | 静态内部类式 | 28ms |
  | 枚举式 | 32ms |
  | 双重检查锁式 | 65ms |

• CountDownLatch类

• • 同步辅助类，在完成一组正在给其他线程中执行操作之前，它允许一个或多个线程一直等待
  • countDown()当前线程调用此方法，则计数减一(建议放在finally里执行)
  • await() 调用此方法会抑制阻塞当前线程，知道计数器的值为0
  • 实例代码：

package testsingleton;

import java.util.concurrent.CountDownLatch;

/**
 * 测试多线程环境下5种创建单例模式的效率
 * @author 橙汁儿Drk
 *
 */

public class Client3 {

	public static void main(String[] args) throws Exception {
		
		long start = System.currentTimeMillis();
        //同步辅助类
		int threadNum = 10;
		CountDownLatch countDownLatch = new CountDownLatch(threadNum);
		
        //线程
		for(int i = 0;i<10;i++) {
			new Thread(new Runnable() {
	
				@Override
				public void run() {
					for(int i = 0;i<100000;i++) {
						Object o = SingletonDemo3.getInstance();
					}
                    //每执行完一个线程，计数器减一
					countDownLatch.countDown();
				}
				
			}).start();;
		}
		
		countDownLatch.await();//main线程阻塞，直到计数器变为0，才会继续往下执行
		
		long end = System.currentTimeMillis();
		System.out.println("总耗时："+(end-start));
		
		
	}
}