创造性的单身派对：探讨单例模式的独一无二之道

原创已于 2023-12-28 21:02:21 修改 · 213 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#单例模式

于 2019-03-06 20:06:49 首次发布

设计模式专栏收录该内容

9 篇文章

订阅专栏

本文深入探讨了Java中的单例模式，介绍了其概念、特点、应用场景及优缺点，并详细解析了五种常见实现方式：饿汉式、懒汉式、双重检测锁式、静态内部类方式和枚举式。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

什么是Singleton?

Singleton:在Java中即指单例设计模式，它是在软件开发中最常用的设计模式之一。
单：唯一
例：实例

单例设计模式，即某个类在整个系统中只能有一个实例对象可被获取和使用的代码模式

单例模式要点：

一是某个类只能有一个实例；

构造器私有化

二是它必须自行创建这个实例；

含有一个该类的静态变量来保存这个唯一的实例

三是它必须自行向整个系统提供这个实例；

对外提供获取该实例对象的方式：

（1）直接暴露

（2）用静态变量的get方法获取

常见应用场景：

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

几种常见形式：

饿汉式：线程安全，调用效率高，不能延迟加载

 * 饿汉式：
 * 	在类初始化时直接创建实例对象，不管你是否需要这个对象都会创建
 */
public class SingletonDemo1 {
	//类初始化时，立即加载这个对象
	private static SingletonDemo1 instance=new SingletonDemo1();
	//构造器私有化
	private SingletonDemo1(){
		
	}
	//方法没有同步，调用效率高。
	public static SingletonDemo1 getInstance(){
		return instance;
	}
}

懒汉式（线程不安全，适用于单线程，调用效率不高，可以延迟加载）

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

双重检测锁式（由于JVM底层模型原因，偶尔会出问题。不建议使用）

public class SingletonDemo3 {    
	    private static volatile SingletonDemo3 instance=null; 
	    
	    private SingletonDemo3(){        
	  
	    }    
	    public static  SingletonDemo3 getInstance(){        
	        if(instance==null){            
	            synchronized(SingletonDemo3.class){                
	                if(instance==null){
	                    instance=new SingletonDemo3();
	                }
	            }
	        }        
	        return instance;
	     }
  }

这个模式将同步内容下方到if内部，提高了执行的效率，不必每次获取对象时都进行同步，只有第一次才同步，创建了以后就没必要了。
这种模式中双重判断加同步的方式，比第一个例子中的效率大大提升，因为如果单层if判断，在服务器允许的情况下，假设有一百个线程，耗费的时间为100*（同步判断时间+if判断时间），而如果双重if判断，100的线程可以同时if判断，理论消耗的时间只有一个if判断的时间。
所以如果面对高并发的情况，而且采用的是懒汉模式，最好的选择就是双重判断加同步的方式。

静态内部类方式（线程安全，适用于多线程，调用效率高，可以延时加载）

 * 在内部类被加载和初始化时，才创建INSTANCE实例对象
 * 静态内部类不会自动随着外部类的加载和初始化而初始化，它是要单独去加载和初始化的。
 * 因为是在内部类加载和初始化时，创建的，因此是线程安全的
 */
public class SingletonDemo4 {

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

枚举式（线程安全，调用效率高，不能延时加载）

* 枚举类型：表示该类型的对象是有限的几个
* 我们可以限定为一个，就成了单例
*/
public enum SingletonDemo5 {
 INSTANCE
}

虽然上面列举出了五种方式，但是根据实例化对象时机的不同只分为两种饿汉式和懒汉式。

如何选用？

单例对象占用资源少，不需要延时加载：

枚举式好于饿汉式

单例对象占用资源大，需要延时加载

静态内部类式好于懒汉式

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

大家只要关注相对应值即可。在不同的环境下不同的程序测得值完全不一样

方式	时间
饿汉式	22ms
懒汉式	636ms
静态内部类	28ms
枚举式	32ms
双重检查锁式	65ms

单例模式的优点：

1，在内存中只有一个对象，节省内存空间。
2，避免频繁的创建销毁对象，可以提高性能。
3，避免对共享资源的多重占用。
4，可以全局访问。

单例模式的缺点：

1，扩展困难，由于getInstance静态函数没有办法生成子类的实例。如果要拓展，只有重写那个类。
2，隐式使用引起类结构不清晰。
3，导致程序内存泄露的问题。

适用场景：

由于单例模式的以上优点，所以是编程中用的比较多的一种设计模式。以下为使用单例模式的场景：

1，需要频繁实例化然后销毁的对象。
2，创建对象时耗时过多或者耗资源过多，但又经常用到的对象。
3，资源共享的情况下，避免由于资源操作时导致的性能或损耗等
4，控制资源的情况下，方便资源之间的互相通信。

单例模式注意事项：

反射可以破解上面几种（不包括枚举式）实现方式（可以在构造方法中手动抛出异常控制）
反序列化可以破解上面几种实现方式！

可以通过定义readResolve()防止获得不同对象。
反序列化时，如果对象所在类定义了readResolve(),(实际是一种回调)

不要做断开单例类对象与类中静态引用的危险操作。
多线程使用单例使用共享资源时，注意线程安全问题。
代码如下：

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

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

测试代码

/**
 * 测试反射和反序列化破解单例模式
 * @author xza
 *
 */
public class Client2 {
	public static void main(String[] args) throws Exception {
		SingletonDemo6 s1=SingletonDemo6.getInstance();
		SingletonDemo6 s2=SingletonDemo6.getInstance();
		
		System.out.println(s1);
		System.out.println(s2);
		
		//通过反射方式直接调用私用构造器
//		Class<SingletonDemo6> clazz=(Class<SingletonDemo6>) Class.forName("com.bjsxt.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);
	    
	    //通过反序列化的方式构造多个对象
		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);
		
	}	
}

关于Java中单例模式的一些常见问题：

单例模式的对象长时间不用会被jvm垃圾收集器收集吗
除非人为地断开单例中静态引用到单例对象的联接，否则jvm垃圾收集器是不会回收单例对象的。
jvm卸载类的判定条件如下：
1，该类所有的实例都已经被回收，也就是java堆中不存在该类的任何实例。
2，加载该类的ClassLoader已经被回收。
3，该类对应的java.lang.Class对象没有任何地方被引用，无法在任何地方通过反射访问该类的方法。
只有三个条件都满足，jvm才会在垃圾收集的时候卸载类。显然，单例的类不满足条件一，因此单例类也不会被回收。

在一个jvm中会出现多个单例吗
在分布式系统、多个类加载器、以及序列化的的情况下，会产生多个单例，这一点是无庸置疑的。那么在同一个jvm中，会不会产生单例呢？使用单例提供的getInstance()方法只能得到同一个单例，除非是使用反射方式，将会得到新的单例。

单例类可以被继承吗
对于这种通过私有化构造函数，静态方法提供实例的单例类而言，是不支持继承的。
这种模式的单例实现要求每个具体的单例类自身来维护单例实例和限制多个实例的生成。但可以采用另外一种实现单例的思路：登记式单例，来使得单例对继承开放。