文档章节

五种单例模式与线程安全

陈祖煌
 陈祖煌
发布于 2014/12/03 22:39
字数 2656
阅读 622
收藏 3

背景

单例模式是一种常用的软件设计模式,常被用于一个类在系统中最多只允许存在一个实例的场合,如窗口管理器、打印缓冲池、文件系统等。在单例模式的核心结构中,只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问,从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个,单例模式是最好的解决方案。在Java中,单例模式如此定义:“一个类有且仅有一个实例,并且自行实例化向整个系统提供。”简而言之,单例模式就是保证一个类最多只能存在一个实例对象


懒汉式

顾名思义,lazy loading(延迟加载,一说懒加载),在需要的时候才创建单例对象,而不是随着软件系统的运行或者当类被加载器加载的时候就创建。当单例类的创建或者单例对象的存在会消耗比较多的资源,常常采用lazy loading策略。这样做的一个明显好处是提高了软件系统的效率,节约内存资源。下面我们看看最简单的懒汉单例模式:

代码1-1

public class Singleton {
	private static Singleton singleton = null;    //私有的、类型为Singleton自身的静态成员变量
	
	//构造方法被设为私有,防止外部使用new来创建对象,破坏单例
	private Singleton(){
		System.out.println("构造函数被调用");
	}
	
	//公有的静态方法,供外部调用来获取单例对象
	public static Singleton getInstance(){
		if(singleton == null){    //第一次调用该方法时,创建对象。
			singleton = new Singleton();
		}
		return singleton;
	}
}

在单线程环境下,多次调用getInstance()方法获得的Singleton对象均为同一个对象,单例模式实现成功。然而,在更多时候,软件系统工作于多线程环境下,因此不得不考虑线程安全的问题。

现有多线程测试程序如下:

代码1-2

public class TestThread {
	public static void main(String[] args) {
		Runnable run = () -> Singleton.getInstance();    //创建实现了Runnable接口的匿名类

		for(int i = 0; i < 50; i++){
			Thread thread = new Thread(run);
			thread.start();
		}
	}
}

代码中先创建了一个实现了Runnable接口的匿名类对象run,然后用for循环创建并启动50个线程,其中一次运行结果如下:

构造函数被调用
构造函数被调用
构造函数被调用
构造函数被调用

显然,Singleton的构造方法不止一次被调用,也就是说,Singleton存在四个实例对象,这违背了单例模式的初衷。这个实验说明,简单的懒汉式在多线程环境下不是线程安全的。有人提出在getInstance()方法上同步锁,但是锁住一整个方法可能粒度过大,不利于效率。既然锁方法不太好,那么锁代码呢?下面我们再看看两个例子:

代码1-3

public class Singleton {
	private static Singleton singleton = null;    
	
	private Singleton(){
		System.out.println("构造函数被调用");
	}
	
	public static Singleton getInstance(){
		if(singleton == null){
			synchronized(Singleton.class){
				singleton = new Singleton();
			}
		}
		return singleton;
	}
}

代码段1-3的getInstance()方法里,在判空语句后上锁,把singleton = new Singleton()语句锁住了,这样做看似解决了线程安全问题,其实不然。设现有线程A和B,在t1时刻线程A和B均已通过判空语句但都未取得锁资源;t2时刻时,A先取得锁资源进入临界区(被锁的代码块),执行new操作创建实例对象,然后退出临界区,释放锁资源。t3时刻,B取得被A释放的锁资源进入临界区,执行new操作创建实例对象,然后退出临界区,释放锁资源。明显地,Singleton被实例化两次。所以,如代码段1-3这样写也不能保证线程安全。

代码1-4

public class Singleton {
	private static Singleton singleton = null;    
	
	private Singleton(){
		System.out.println("构造函数被调用");
	}
	
	public static Singleton getInstance(){
	        synchronized(Singleton.class){
		        if(singleton == null){
				singleton = new Singleton();
			}
		}
		return singleton;
	}
}

    代码段1-4把代码锁放在了判空语句前,这样做避免了代码段1-3的问题,然而这样做类似于在方法签名上加上synchronized关键字,会影响程序效率。因为当有多个线程几乎同时访问getInstance方法时,多个线程必须有次序地进入方法内,这样导致了若干个线程需要耗费等待进入临界区(被锁住的代码块)的时间。基于此,有人提出了双重校验锁式。


双重校验锁DCL(double checked locking)

双重校验锁式(也有人把双重校验锁式和懒汉式归为一类)分别在代码锁前后进行判空校验,避免了多个有机会进入临界区的线程都创建对象,同时也避免了代码段1-4后来线程在先来线程创建对象后但仍未退出临界区的情况下等待。双重校验锁代码如下:

代码2-1

public class Singleton{
        private volatile static Singleton singleton = null;    //注意此处加上了volatile关键字
	
	private Singleton(){
		System.out.println("构造函数被调用");
	}
	
	public static Singleton getInstance(){
		if(singleton == null){
			synchronized(Singleton.class){
				if(singleton == null){
					singleton = new Singleton();
					//return singleton;    //有人提议在此处进行一次返回
				}
				//return singleton;    //也有人提议在此处进行一次返回
			}
		}
		return singleton;
	}
}

经多次试验说明,双重校验锁式是线程安全的。然而,在JDK1.5以前,DCL是不稳定的,有时也可能创建多个实例,在1.5以后开始提供volatile关键字修饰变量来达到稳定效果。


饿汉式

单例模式的饿汉式,在定义自身类型的成员变量时就将其实例化,使得在Singleton单例类被系统(姑且这么说)加载时就已经被实例化出一个单例对象,从而一劳永逸地避免了线程安全的问题。代码如下:

代码3-1

public class Singleton{
        private static Singleton singleton = new Singleton();    //在定义变量时就将其实例化
	
	private Singleton(){
		System.out.println("构造函数被调用");
	}
	
	public static Singleton getInstance(){
		return singleton;
	}
}

使用多线程测试代码1-2进行测试,单例模式成功实现。

我想应该有朋友对饿汉式单例在何时被实例化感兴趣。可以编写如下简单测试代码:

代码3-2

public class TestThread {
	public static void main(String[] args) {
		Class.forName("Singleton");
	}
}

运行这段代码后可以看到控制台有“构造函数被调用”字符串输出,说明在ClassLoader加载Singleton类时,饿汉式单例就被创建。

虽然饿汉式单例是线程安全的,但也有其不足之处。饿汉式单例在类被加载时就创建单例对象并且长驻内存,不管你需不需要它;如果单例类占用的资源比较多,就会降低资源利用率以及程序的运行效率。有一种更高级的单例模式则很好地解决了这个问题——静态内部类。


静态内部类

静态内部类式在Singleton类内部定义了一个静态的内部类,在该内部类里创建Singleton的单例对象。我们先看代码:

代码4-1

public class Singleton {
	private Singleton(){
		System.out.println("构造函数被调用");
	}
	
	public static Singleton getInstance(){
		return SingletonHolder.instance;
	}
	
	private static class SingletonHolder{
		private static Singleton instance = new Singleton();
	}
}

静态内部类式和饿汉式一样,同样利用了ClassLoader的机制保证了线程安全;不同的是,饿汉式在Singleton类被加载时(从代码段3-2的Class.forName可见)就创建了一个实例对象,而静态内部类即使Singleton类被加载也不会创建单例对象,除非调用里面的getInstance()方法。因为当Singleton类被加载时,其静态内部类SingletonHolder没有被主动使用。只有当调用getInstance方法时,才会装载SingletonHolder类,从而实例化单例对象。

这样,通过静态内部类的方法就实现了lazy loading,很好地将懒汉式和饿汉式结合起来,既实现延迟加载,保证系统性能,也能保证线程安全


然而,对于上述四种方式的单例模式,如果你的Singleton类实现了Serializable序列化接口,那么可能会被序列化生成多个实例,因为readObject()方法一直返回一个新的对象:

ByteArrayOutputStream baos  = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(singleton);
 
ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(baos.toByteArray()));
Singleton singleton=  (Singleton) ois.readObject();

这种情况可以通过在Singleton类添加readResolve()方法来解决:

private Object readResolve() {
        System.out.println("readResolve()被调用");
        return getInstance();
}

但是这种解决方案虽解决了序列化的问题,但是无法避免被反射。下面还有一种枚举单例,写法简单,还可以避免序列化、反射的问题。


枚举单例

上面说到的静态内部类方式不失为一个高级的单例模式实现。但如果开发要求更严格一些,比如你的Singleton类实现了序列化,又或者想避免通过反射来破解单例模式的话,单例模式还可以有另一种形式。那就是枚举单例。枚举类型在JDK1.5被引进。这种方式也是《Effective Java》作者Josh Bloch 提倡的方式,它不仅能避免多线程的问题,而且还能防止反序列化重新创建新的对象、防止被反射攻击。代码如下:

代码5-1

public enum EnumSingleton {
	INSTANCE{
		@Override
		protected void work() {
			System.out.println("你好,是我!");
		}
		
	};
	
	protected abstract void work();    //单例需要进行操作(也可以不写成抽象方法)
}

在外部,可以通过EnumSingleton.INSTANCE.work()来调用work方法。默认的枚举实例的创建是线程安全的,但是实例内的各种方法则需要程序员来保证线程安全。总的来说,使用枚举单例模式,有三个好处:1.实例的创建线程安全,确保单例。2.防止被反射创建多个实例。3.没有序列化的问题。



From:陈祖煌

Blog:http://my.oschina.net/chenzuhuang/blog

转载必须说明出处

---------------------------------------------------------------------------------------------

© 著作权归作者所有

共有 人打赏支持
陈祖煌
粉丝 15
博文 9
码字总数 15756
作品 0
深圳
程序员
私信 提问
java设计模式-- 单例模式

在很久之前,也就是在大二暑假的时候,那时候看马士兵的视频教程中有提到很多的设计模式。 java的设计模式大致可以分为3大类,23种设计模式。 其中,创建型模式有5种:单例模式、建造者模式、...

爱学习的逃课君
2014/11/27
0
0
设计模式梳理(一)

设计模式梳理(一) 总体来说设计模式分为三大类: @案例源码地址:https://gitlab.com/lxqxsyu/DisgnPattern 创建型模式 简单工厂模式 工厂类是整个模式的关键。它包含必要的判断逻辑,能够...

lxq_xsyu
2017/11/02
0
0
设计模式:单例模式的写法(基础写法和线程安全写法)

单例模式的写法很多,先给出一种最基础的写法: (A种写法): A写法是单例模式最简单、最基础、最清晰的写法,但遗憾的是这种写法是线程不安全的代码写法。假设该类同时在并发N多个线程中被...

开开心心过
2015/07/17
0
0
Objective-C中单例模式的实现

单例模式在Cocoa和Cocoa Touch中非常常见。比如这两个,[UIApplication sharedApplication]和[NSApplication sharedApplication],大家应该都见过。但是我们应该如何在代码中实现一个单例模式...

雾灵峰
2013/03/24
0
0
我的Java设计模式-单例模式

  就算不懂设计模式的兄弟姐妹们,想必也听说过单例模式,并且在项目中也会用上。但是,真正理解和熟悉单例模式的人有几个呢?接下来我们一起来学习设计模式中最简单的模式之一——单例模式...

Jet啟思
2017/10/26
0
0

没有更多内容

加载失败,请刷新页面

加载更多

(三)Honghu Cloud云架构一定时调度平台

2018-11-16 14:45:08 产品简介 鸿鹄云架构是一个完全由Java编写的开源任务调度框架,为企业在任务调度提供了简单却强大的机制。开发人员根据业务规则,使用调度平台简单配置,就可以让任务在...

itcloud
28分钟前
2
0
护航Lazada双11购物节 阿里云CDN全球化火力全开

摘要: Lazada是东南亚最大B2C平台,业务范围覆盖印度尼西亚、马来西亚、菲律宾、新加坡、泰国和越南六个东南亚国家,覆盖大约6亿消费者。在双11期间,阿里云CDN为Lazada电商内容加速,并且通...

阿里云官方博客
28分钟前
2
0
常用设计模式之代理模式解析

1. 简介 代理模式(Proxy Pattern)是常用设计模式之一。代理模式的定义:Provide a surrogate or placeholder for another object to controlaccess to it(为其他对象提供一种代理以控制对这个...

老道士
28分钟前
5
0
Vue瀑布流插件的使用示例

我自己写的一个的Vue瀑布流插件,列数自适应,不用设置每个卡片的高度。 测试页面:Page.vue 模板页面:WaterFollow.vue 和 WFColumn.vue 在Page.vue中,修改itemW的值,设置每列的最小宽度。...

peakedness丶
29分钟前
4
0
多种负载均衡算法及其Java代码实现【网络上较好的转载】

首先给大家介绍下什么是负载均衡(来自百科) 负载均衡 建立在现有网络结构之上,它提供了一种廉价有效透明的方法扩展 网络设备和 服务器的带宽、增加 吞吐量、加强网络数据处理能力、提高网...

stys352
33分钟前
2
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部