单例设计模式

单例设计模式

一、单例设计模式概述

1. 作用
   保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。
2. 常见应用场景
   • Windows的Task Manager（任务管理器）就是很典型的单例模式
   • 项目中，读取配置文件的类，一般也只有一个对象。没有必要每次使用配置文件数据，每次new一个对象去读取。
   • 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。
   • Application 也是单例的典型应用（Servlet编程中会涉及到）
   • 在servlet编程中，每个Servlet也是单例
3. 单例模式设计优点
   • 由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要 比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动 时直接产生一个单例对象，然后永久驻留内存的方式来解决
   • 单例模式可以在系统设置全局的访问点，优化环共享资源访问，例如可以设计 一个单例类，负责所有数据表的映射处理
4. 常见的五种单例模式实现方式
   • 恶汉式（线程安全，调用效率高。 但是，不能延时加载。）
   • 懒汉式（线程安全，调用效率不高。 但是，可以延时加载。）
   • 双重检测锁式（由于JVM底层内部模型原因，偶尔会出问题。不建议使用）
   • 静态内部类式(线程安全，调用效率高。 但是，可以延时加载)
   • 枚举单例(线程安全，调用效率高，不能延时加载)
5. 如何选用
   • 单例对象 占用 资源 少，不需要 延时加载： 枚举式 好于 饿汉式
   • 单例对象 占用 资源 大，需要 延时加载： 静态内部类式 好于 懒汉式

二、饿汉式实现

public class SingletonDemo1 {
	
	//类初始化时，立即加载这个对象（没有延时加载的优势）。加载类时，天然的是线程安全的！
	//问题：如果只是加载本类，而不调用getInstance()，甚至永远没有调用，则会造成资源浪费！
	private static SingletonDemo1 instance = new SingletonDemo1();  
	
	private SingletonDemo1(){
	}
	
	//方法没有同步，调用效率高！
	public static SingletonDemo1  getInstance(){
		return instance;
	}
	
}

三、懒汉式实现（单例对象延迟加载）

public class SingletonDemo2 {
	
	//类初始化时，不初始化这个对象（延时加载，真正用的时候再创建）。
	//问题：资源利用率高了。但是，每次调用getInstance()方法都要同步，并发 效率较低。
	private static SingletonDemo2 instance;  
	
	private SingletonDemo2(){ //私有化构造器
	}
	
	//方法同步，调用效率低！
	public static  synchronized SingletonDemo2  getInstance(){
		if(instance==null){
			instance = new SingletonDemo2();
		}
		return instance;
	}	
}

四、双重检查锁实现单例模式

public class SingletonDemo3 { 

  private static SingletonDemo3 instance = null; 
  //这个模式将同步内容下方到if内部，提高了执行的效率 
  //不必每次获取对象时都进行同步，只有第一次才同步 创建了以后就没必要了。
  public static SingletonDemo3 getInstance() { 
    if (instance == null) { 
      SingletonDemo3 sc; 
      synchronized (SingletonDemo3.class) { 
        sc = instance; 
        if (sc == null) { 
          synchronized (SingletonDemo3.class) { 
            if(sc == null) { 
              sc = new SingletonDemo3(); 
            } 
          } 
          instance = sc; 
        } 
      } 
    } 
    return instance; 
  } 

  private SingletonDemo3() { 

  } 
    
}

五、静态内部类实现方式(也是一种懒加载方式)

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

	private static class SingletonClassInstance {
		private static final SingletonDemo4 instance = new SingletonDemo4();
	}
	
	private SingletonDemo4(){
	}
	
	//方法没有同步，调用效率高！
	public static SingletonDemo4  getInstance(){
		return SingletonClassInstance.instance;
	}
	
}

六、举式实现单例模式(没有延时加载)

public enum SingletonDemo5 {
	
	//这个枚举元素，本身就是单例对象！
	INSTANCE;
	
	//添加自己需要的操作！
	public void singletonOperation(){
	}
	
}

七、测试反射破解单例模式

public class Client2 {
	
	public static void main(String[] args) throws Exception {
		
		
		//通过反射的方式直接调用私有构造器
		Class<SingletonDemo6> clazz = (Class<SingletonDemo6>) Class.forName("cn.wj.singleton.SingletonDemo6");
		Constructor<SingletonDemo6> c = clazz.getDeclaredConstructor(null);
		c.setAccessible(true);
		SingletonDemo6  s3 = c.newInstance();
		SingletonDemo6  s4 = c.newInstance();
		System.out.println(s3);
		System.out.println(s4);
	}
}
//防止破解的方法：在类的构造器中加一个判断：
//	private SingletonDemo6(){ 
//		if(instance!=null){
//			throw new RuntimeException();
//		}
//	}

八、测试反序列化破解单例模式

public class Client2 {
	
	public static void main(String[] args) throws Exception {

		//通过反序列化的方式构造多个对象 
		FileOutputStream fos = new FileOutputStream("d:/a.txt");
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		oos.writeObject(s1);
		oos.close();
		fos.close();
		
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:/a.txt"));
		SingletonDemo6 s3 =  (SingletonDemo6) ois.readObject();
		System.out.println(s3);
		
	}
}
//防止破解的方法：在类中再定义一个方法
//反序列化时，如果定义了readResolve()则直接返回此方法指定的对象。而不需要单独再创建新对象！
//	private Object readResolve() throws ObjectStreamException {
//		return instance;
//	}