单例模式的疑问
2015-09-27 10:01
351 查看
面试的时候,常常会被问到这样一个问题:请您写出一个单例模式(Singleton Pattern)吧。好吧,写就写,这还不容易。顺手写一个:
public
final class
EagerSingleton
{
private
static EagerSingleton
singObj = new
EagerSingleton();
private
EagerSingleton(){
}
public
static EagerSingleton
getSingleInstance(){
return
singObj;
}
}
这种写法就是所谓的饥饿模式,每个对象在没有使用之前就已经初始化了。这就可能带来潜在的性能问题:如果这个对象很大呢?没有使用这个对象之前,就把它加载到了内存中去是一种巨大的浪费。针对这种情况,我们可以对以上的代码进行改进,使用一种新的设计思想——延迟加载(Lazy-load Singleton)。
public
final class
LazySingleton
{
private
static LazySingleton
singObj = null;
private
LazySingleton(){
}
public
static LazySingleton
getSingleInstance(){
if(null ==
singObj ) singObj = new LazySingleton();
return
singObj;
}
}
这种写法就是所谓的懒汉模式。它使用了延迟加载来保证对象在没有使用之前,是不会进行初始化的。但是,通常这个时候面试官又会提问新的问题来刁难一下。他会问:这种写法线程安全吗?回答必然是:不安全。这是因为在多个线程可能同时运行到第九行,判断singObj为null,于是同时进行了初始化。所以,这是面临的问题是如何使得这个代码线程安全?很简单,在那个方法前面加一个Synchronized就OK了。
public
final class
ThreadSafeSingleton
{
private
static ThreadSafeSingleton
singObj = null;
private
ThreadSafeSingleton(){
}
public
static
SynchronizedThreadSafeSingleton getSingleInstance(){
if(null
== singObj
) singObj = new
ThreadSafeSingleton();
return
singObj;
}
}
写到这里,面试官可能仍然会狡猾的看了你一眼,继续刁难到:这个写法有没有什么性能问题呢?答案肯定是有的!同步的代价必然会一定程度的使程序的并发度降低。那么有没有什么方法,一方面是线程安全的,有可以有很高的并发度呢?我们观察到,线程不安全的原因其实是在初始化对象的时候,所以,可以想办法把同步的粒度降低,只在初始化对象的时候进行同步。这里有必要提出一种新的设计思想——双重检查锁(Double-Checked
Lock)。
public
final class
DoubleCheckedSingleton
{
private
static DoubleCheckedSingletonsingObj
= null;
private
DoubleCheckedSingleton(){
}
public
staticDoubleCheckedSingleton getSingleInstance(){
if(null
== singObj
) {
Synchronized
d43c
(DoubleCheckedSingleton.class){
if(null
== singObj)
singObj = new
DoubleCheckedSingleton();
}
}
return
singObj;
}
}
这种写法使得只有在加载新的对象进行同步,在加载完了之后,其他线程在第九行就可以判断跳过锁的的代价直接到第15行代码了。做到很好的并发度。
至此,上面的写法一方面实现了Lazy-Load,另一个方面也做到了并发度很好的线程安全,一切看上很完美。这是,面试官可能会对你的回答满意的点点头。但是,你此时提出说,其实这种写法还是有问题的!!问题在哪里?假设线程A执行到了第9行,它判断对象为空,于是线程A执行到第12行去初始化这个对象,但初始化是需要耗费时间的,但是这个对象的地址其实已经存在了。此时线程B也执行到了第九行,它判断不为空,于是直接跳到15行得到了这个对象。但是,这个对象还没有被完整的初始化!得到一个没有初始化完全的对象有什么用!!关于这个Double-Checked
Lock的讨论有很多,目前公认这是一个Anti-Pattern,不推荐使用!所以当你的面试官听到你的这番答复,他会不会被Hold住呢?
那么有没有什么更好的写法呢?有!这里又要提出一种新的模式——Initialization on Demand Holder.
这种方法使用内部类来做到延迟加载对象,在初始化这个内部类的时候,JLS(Java Language Sepcification)会保证这个类的线程安全。这种写法最大的美在于,完全使用了Java虚拟机的机制进行同步保证,没有一个同步的关键字。
public
class Singleton
{
private
static class
SingletonHolder
{
public
final static Singleton instance = new
Singleton();
}
public
static Singleton
getInstance()
{
return
SingletonHolder.instance;
}
}
至此,本文完。提供一些链接For your reference:
Double-Checked Lock:http://en.wikipedia.org/wiki/Double-checked_locking
Initialzation on Demand Holder: http://en.wikipedia.org/wiki/Initialization_on_demand_holder_idiom
public
final class
EagerSingleton
{
private
static EagerSingleton
singObj = new
EagerSingleton();
private
EagerSingleton(){
}
public
static EagerSingleton
getSingleInstance(){
return
singObj;
}
}
这种写法就是所谓的饥饿模式,每个对象在没有使用之前就已经初始化了。这就可能带来潜在的性能问题:如果这个对象很大呢?没有使用这个对象之前,就把它加载到了内存中去是一种巨大的浪费。针对这种情况,我们可以对以上的代码进行改进,使用一种新的设计思想——延迟加载(Lazy-load Singleton)。
public
final class
LazySingleton
{
private
static LazySingleton
singObj = null;
private
LazySingleton(){
}
public
static LazySingleton
getSingleInstance(){
if(null ==
singObj ) singObj = new LazySingleton();
return
singObj;
}
}
这种写法就是所谓的懒汉模式。它使用了延迟加载来保证对象在没有使用之前,是不会进行初始化的。但是,通常这个时候面试官又会提问新的问题来刁难一下。他会问:这种写法线程安全吗?回答必然是:不安全。这是因为在多个线程可能同时运行到第九行,判断singObj为null,于是同时进行了初始化。所以,这是面临的问题是如何使得这个代码线程安全?很简单,在那个方法前面加一个Synchronized就OK了。
public
final class
ThreadSafeSingleton
{
private
static ThreadSafeSingleton
singObj = null;
private
ThreadSafeSingleton(){
}
public
static
SynchronizedThreadSafeSingleton getSingleInstance(){
if(null
== singObj
) singObj = new
ThreadSafeSingleton();
return
singObj;
}
}
写到这里,面试官可能仍然会狡猾的看了你一眼,继续刁难到:这个写法有没有什么性能问题呢?答案肯定是有的!同步的代价必然会一定程度的使程序的并发度降低。那么有没有什么方法,一方面是线程安全的,有可以有很高的并发度呢?我们观察到,线程不安全的原因其实是在初始化对象的时候,所以,可以想办法把同步的粒度降低,只在初始化对象的时候进行同步。这里有必要提出一种新的设计思想——双重检查锁(Double-Checked
Lock)。
public
final class
DoubleCheckedSingleton
{
private
static DoubleCheckedSingletonsingObj
= null;
private
DoubleCheckedSingleton(){
}
public
staticDoubleCheckedSingleton getSingleInstance(){
if(null
== singObj
) {
Synchronized
d43c
(DoubleCheckedSingleton.class){
if(null
== singObj)
singObj = new
DoubleCheckedSingleton();
}
}
return
singObj;
}
}
这种写法使得只有在加载新的对象进行同步,在加载完了之后,其他线程在第九行就可以判断跳过锁的的代价直接到第15行代码了。做到很好的并发度。
至此,上面的写法一方面实现了Lazy-Load,另一个方面也做到了并发度很好的线程安全,一切看上很完美。这是,面试官可能会对你的回答满意的点点头。但是,你此时提出说,其实这种写法还是有问题的!!问题在哪里?假设线程A执行到了第9行,它判断对象为空,于是线程A执行到第12行去初始化这个对象,但初始化是需要耗费时间的,但是这个对象的地址其实已经存在了。此时线程B也执行到了第九行,它判断不为空,于是直接跳到15行得到了这个对象。但是,这个对象还没有被完整的初始化!得到一个没有初始化完全的对象有什么用!!关于这个Double-Checked
Lock的讨论有很多,目前公认这是一个Anti-Pattern,不推荐使用!所以当你的面试官听到你的这番答复,他会不会被Hold住呢?
那么有没有什么更好的写法呢?有!这里又要提出一种新的模式——Initialization on Demand Holder.
这种方法使用内部类来做到延迟加载对象,在初始化这个内部类的时候,JLS(Java Language Sepcification)会保证这个类的线程安全。这种写法最大的美在于,完全使用了Java虚拟机的机制进行同步保证,没有一个同步的关键字。
public
class Singleton
{
private
static class
SingletonHolder
{
public
final static Singleton instance = new
Singleton();
}
public
static Singleton
getInstance()
{
return
SingletonHolder.instance;
}
}
至此,本文完。提供一些链接For your reference:
Double-Checked Lock:http://en.wikipedia.org/wiki/Double-checked_locking
Initialzation on Demand Holder: http://en.wikipedia.org/wiki/Initialization_on_demand_holder_idiom
相关文章推荐
- 谷歌 Project Zero 团队宣布新政策,漏洞披露前将有完整的 90 天缓冲期
- 春节长假安全手册
- 地震避险自救常识
- 路由器安全有关的目录
- 打造个性_安全的电脑系统图文教程2第1/2页
- 路由器内的安全认证
- 加强php的安全之一
- http www安全必备知识
- SQLServer 2008中的代码安全(一) 存储过程加密与安全上下文
- C语言安全编码之数值中的sizeof操作符
- PHP安全上传图片的方法
- C#实现线程安全的简易日志记录方法
- .NET中保证线程安全的高级方法Interlocked类使用介绍
- php 编写安全的代码时容易犯的错误小结
- JSP应用的安全问题
- .NET c# 单体模式(Singleton)
- asp.net安全、实用、简单的大容量存储过程分页第1/2页