欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识！
您现在的位置是： 首页  >  科技

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

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

单例模式

核心作用：

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

• 常见应用场景：

– 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线程继续往下走
单例模式实现方式以及漏洞和解决方案

本文地址：https://blog.csdn.net/weixin_44805105/article/details/110277953

相关标签： GOF23

上一篇： 春节到香港必去的十个地方 不容错过的精彩

下一篇： Spring 基于注解的IoC

推荐阅读