单例模式实现方式以及漏洞和解决方案

最新推荐文章于 2023-11-19 15:34:22 发布

you些话

最新推荐文章于 2023-11-19 15:34:22 发布

阅读量453

点赞数 2

分类专栏： GOF23

本文链接：https://blog.csdn.net/weixin_44805105/article/details/110277953

版权

GOF23 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

单例模式

核心作用：

– 保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。

• 常见应用场景：

– Windows的Task Manager（任务管理器）就是很典型的单例模式
– windows的Recycle Bin（回收站）也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。
– 项目中，读取配置文件的类，一般也只有一个对象。没有必要每次使用配置文件数据，每次new一个对象去读取。
– 网站的计数器，一般也是采用单例模式实现，否则难以同步。
– 应用程序的日志应用，一般都何用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。
– 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。
– 操作系统的文件系统，也是大的单例模式实现的具体例子，一个操作系统只能有一个文件系统。
– Application 也是单例的典型应用（Servlet编程中会涉及到）
– 在Spring中，每个Bean默认就是单例的，这样做的优点是Spring容器可以管理
– 在servlet编程中，每个Servlet也是单例
– 在spring MVC框架/struts1框架中，控制器对象也是单例

单例模式的优点：

   – 由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要 比较多的资源时，
   如读取配置、产生其他依赖对象时，则可以通过在应用启动 时直接产生一个单例对象，
   然后永久驻留内存的方式来解决
    – 单例模式可以在系统设置全局的访问点，优化环共享资源访问，例如可以设计 一个单例类，
    负责所有数据表的映射处理

• 常见的五种单例模式实现方式：
– 主要：
• 饿汉式（线程安全，调用效率高。但是，不能延时加载。）
• 懒汉式（线程安全，调用效率不高。但是，可以延时加载。）
– 其他：
• 双重检测锁式（由于JVM底层内部模型原因，偶尔会出问题。不建议使用）
• 静态内部类式(线程安全，调用效率高。但是，可以延时加载)
• 枚举单例(线程安全，调用效率高，不能延时加载)

五种单例模式代码示例：

饿汉式：

package com.lzy.singletion;

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

懒汉式：

package com.lzy.singletion;

public class SingletonDemo02 {

	/**
	 * 测试懒汉式单例模式
	 */
	//类初始化，不初始化这个对象（延时加载，真正用的时候再创建）
	private static SingletonDemo02 instance;
	
	private SingletonDemo02() {
		
	}
	//方法同步，调用效率低
	public static synchronized SingletonDemo02 getInstance() {
		if(instance==null) {
			instance=new SingletonDemo02();
		}
		return instance;
	}
}

双重检测锁式：

package com.lzy.singletion;

public class SingletonDemo03 { 
/**
 * 双重检查锁实现单例模式,不建议这样使用，可能会偶尔出错
 */
	  private static SingletonDemo03 instance = null; 

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

	  private SingletonDemo03() { 

	  } 
	    
	}

静态内部类式：

package com.lzy.singletion;

public class SingletonDemo04 { 
/**
 * 测试静态内部类实现单例模式
 * 这种方式：线程安全，调用效率高，并且实现了延时加载！
 **/
	 private static class SingletonClassInstance{
		 private static final SingletonDemo04 instance=new SingletonDemo04();
	 }
	 private SingletonDemo04() {
		 
	 }
	 //方法没有同步，调用效率高
	 public static SingletonDemo04 getInstance() {
		 return SingletonClassInstance.instance;
	 }
	    
	}

枚举式：

package com.lzy.singletion;

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

测试单一模式：

package com.lzy.singletion;

public class Client {
public static void main(String[] args) {
	SingletonDemo04 s1=SingletonDemo04.getInstance();
	SingletonDemo04 s2=SingletonDemo04.getInstance();
	System.out.println(s1);
	System.out.println(s2);
}
}

运行结果：
com.lzy.singletion.SingletonDemo04@5305068a
com.lzy.singletion.SingletonDemo04@5305068a
说明虽然创造了两个对象s1,s2但运行结果显示这两个对象其实是同一个对象。

通过反射破解单例模式

package com.lzy.singletion;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;

public class Client02 {
public static void main(String[] args) throws Exception {
	SingletonDemo06 s1=SingletonDemo06.getInstance();
	SingletonDemo06 s2=SingletonDemo06.getInstance();
	System.out.println(s1);
	System.out.println(s2);
	
	
	//通过反射的方式直接调用私有构造器
	try {
		Class<SingletonDemo06> clazz=(Class<SingletonDemo06>)Class.forName("com.lzy.singletion.SingletonDemo06");
		Constructor<SingletonDemo06> c=clazz.getDeclaredConstructor(null);//获得构造器
		c.setAccessible(true);//跳过权限检查，可访问私有
		SingletonDemo06 s3=c.newInstance();
		SingletonDemo06 s4=c.newInstance();
		System.out.println(s3);
		System.out.println(s4);
		
	} catch (Exception e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}

}
}

运行结果：
com.lzy.singletion.SingletonDemo06@28a418fc
com.lzy.singletion.SingletonDemo06@28a418fc
com.lzy.singletion.SingletonDemo06@5305068a
com.lzy.singletion.SingletonDemo06@1f32e575
可以看s1,s2是同一对象，s3,s4通过反射，与s1,s2不是同一个对象

如何解决漏洞？

package com.lzy.singletion;

import java.io.Serializable;

public class SingletonDemo06 implements Serializable{ 
/**
 * 懒汉式
 * 如何防止反射和反序列化漏洞
 **/
	//类初始化时，不初始化这个对象（延时加载，真正用时再创建）
	private static SingletonDemo06 instance;
	private SingletonDemo06() {
		if(instance!=null) {//防止反射漏洞
		throw new RuntimeException();
		}
	}
	
	//方法同步，调用效率低！
	public static synchronized SingletonDemo06 getInstance() {
		if(instance ==null) {
			instance=new SingletonDemo06();
		}
		return instance;
	}
	
	
	
	}

再SingletonDemo06的空构造器（13-15）加上以下代码

if(instance!=null) {//防止反射漏洞
		throw new RuntimeException();
		}

即可。

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

package com.lzy.singletion;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;

public class Client02 {
public static void main(String[] args) throws Exception {
	SingletonDemo06 s1=SingletonDemo06.getInstance();
	SingletonDemo06 s2=SingletonDemo06.getInstance();
	System.out.println(s1);
	System.out.println(s2);
	
	
//	//通过反射的方式直接调用私有构造器‘
//	try {
//		Class<SingletonDemo06> clazz=(Class<SingletonDemo06>)Class.forName("com.lzy.singletion.SingletonDemo06");
//		Constructor<SingletonDemo06> c=clazz.getDeclaredConstructor(null);//获得构造器
//		c.setAccessible(true);//跳过权限检查，可访问私有
//		SingletonDemo06 s3=c.newInstance();
//		SingletonDemo06 s4=c.newInstance();
//		System.out.println(s3);
//		System.out.println(s4);
//		
//	} catch (Exception e) {
//		// TODO Auto-generated catch block
//		e.printStackTrace();
//	}
//	
	//通过反序列化的方式构造多个对象
	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"));
	SingletonDemo06 s3 =  (SingletonDemo06) ois.readObject();
	System.out.println(s3);
	
}
}

运行结果：
com.lzy.singletion.SingletonDemo06@28a418fc
com.lzy.singletion.SingletonDemo06@28a418fc
com.lzy.singletion.SingletonDemo06@31221be2
可以看出s3通过反序列化与s1,s2不是同一个对象

如何解决？

package com.lzy.singletion;

import java.io.Serializable;

public class SingletonDemo06 implements Serializable{ 
/**
 * 懒汉式
 * 如何防止反射和反序列化漏洞
 **/
	//类初始化时，不初始化这个对象（延时加载，真正用时再创建）
	private static SingletonDemo06 instance;
	private SingletonDemo06() {
		if(instance!=null) {//防止反射漏洞
		throw new RuntimeException();
		}
	}
	
	//方法同步，调用效率低！
	public static synchronized SingletonDemo06 getInstance() {
		if(instance ==null) {
			instance=new SingletonDemo06();
		}
		return instance;
	}
	
	//反序列化时，如果定义了readResolve()则直接返回此方法指定的对象。而不需要单独在创建新对象
	private Object readResolve() {
		return instance;
	}
	
	}

在SingletonDemo06类中加入以下方法即可

//反序列化时，如果定义了readResolve()则直接返回此方法指定的对象。而不需要单独在创建新对象
	private Object readResolve() {
		return instance;
	}

常见的五种单例模式在多线程环境下的效率测试

饿汉式	7
懒汉式	83
静态内部类式	8
枚举式	11
双重检查锁式	19

测试代码：

package com.lzy.singletion;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;
import java.util.concurrent.CountDownLatch;

public class Client03 {

	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<threadNum;i++){
			new Thread(new Runnable() {
				@Override
				public void run() {
					
					for(int i=0;i<1000000;i++){
//						Object o = SingletonDemo04.getInstance();
						Object o = SingletonDemo05.INSTANCE;
					}
					
					countDownLatch.countDown();
				}
			}).start();
		}
		
		countDownLatch.await();	//main线程阻塞，直到计数器变为0，才会继续往下执行！
		
		long end = System.currentTimeMillis();
		System.out.println("总耗时："+(end-start));
	}
}

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

如果没有该方法，代码线程如下图所示，线程main不会等10个线程运行完，才继续，而是在10个线程运行时，main线程可能就运行到long end = System.currentTimeMillis();结果导致不同单例模式运行的耗时不准确，
而加入之后会等到10个线程运行完，才继续往下走。16行的实参要和18行for（）里面的一致（也就是线程数），28行countDownLatch.countDown();意思每执行完一个线程，threadNum就会减一，直到10个线程运行完，减到0，main线程继续往下走
在这里插入图片描述

you些话

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
单例模式实现方式以及漏洞和解决方案

单例模式核心作用：– 保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。• 常见应用场景：– Windows的Task Manager（任务管理器）就是很典型的单例模式– windows的Recycle Bin（回收站）也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。– 项目中，读取配置文件的类，一般也只有一个对象。没有必要每次使用配置文件数据，每次new一个对象去读取。– 网站的计数器，一般也是采用单例模式实现，否则难以同步。– 应用程序的日志应用，一般
复制链接

扫一扫