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

发布时间:2023年12月26日

单例模式

  • 核心作用:
    • 保证一个类只有一个实例,并且提供一个访问该实例的全局访问点
  • 常见应用场景
    • 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));
		
		
	}
}
文章来源:https://blog.csdn.net/CoderChronicle/article/details/135115570
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。