- 浏览: 157368 次
- 性别:
- 来自: 北京
文章分类
- 全部博客 (130)
- Database (5)
- JavaSE (23)
- JavaScript (11)
- Struts2 (15)
- Hibernate (11)
- Spring (16)
- Linux (4)
- Jquery (3)
- Tools (12)
- Jsp (7)
- 杂谈 (9)
- WEB Project (10)
- WebService (16)
- maven (2)
- android (1)
- memcache (2)
- 网络通信 (4)
- solr (1)
- cxf (7)
- powerdesigner (1)
- jxls (1)
- springmvc (1)
- nosql (1)
- node.js (0)
- thrift (0)
- REST (1)
- tag (1)
最新评论
单例模式(Singleton Pattern)
前面说提到的五种创建模式,主要解决的问题是如何创建对象,获得产品。而单例模式最要关心的则是对象创建的次数以及何时被创建。
Singleton模式可以是很简单的,它的全部只需要一个类就可以完成(看看这章可怜的UML图)。但是如果在“对象创建的次数以及何时被创建”这两点上较真起来,Singleton模式可以相当的复杂,比头五种模式加起来还复杂,譬如涉及到DCL双锁检测(double checked locking)的讨论、涉及到多个类加载器(ClassLoader)协同时、涉及到跨JVM(集群、远程EJB等)时、涉及到单例对象被销毁后重建等。对于复杂的情况,本章中会涉及到其中一些[1]
目的:
希望对象只创建一个实例,并且提供一个全局的访问点。
场景:
Kerrigan对于Zerg来说是个至关重要的灵魂人物,无数的Drone、Zergling、Hydralisk……可以被创造、被牺牲,但是Kerrigan得存在关系到Zerg在这局游戏中的生存,而且Kerrigan是不允许被多次创造的,必须有且只有一个虫族刀锋女王的实例存在,这不是游戏规则,但这是个政治问题。
分析:
如前面一样,我们还是尝试使用代码来描述访问Kerrigan的过程,看看下面的UML图,简单得我都不怎么好意思放上来占版面。
图6.1 单例模式的UML图
结构是简单的,只是我们还有一些小小的要求如下:
1.最基本要求:每次从getInstance()都能返回一个且唯一的一个Kerrigan对象。
2.稍微高一点的要求:Kerrigan很忙,很多人找,所以希望这个方法能适应多线程并发访问。
3.再提高一点的要求:Zerg是讲究公务员效率的社会,希望找Kerrigan的方法性能尽可能高。
4.最后一点要求是Kerrigan自己提出的:体谅到Kerrigan太累,希望多些睡觉时间,因此Kerrigan希望实现懒加载(Lazy Load),在需要的时候才被构造。
5.原本打算说还提要处理多ClassLoader、多JVM等情况,不过还是不要把情况考虑的太复杂了,暂且先放过作者吧(-_-#)。
我们第一次写的单例模式是下面这个样子的:
Java代码
/**
* 实现单例访问Kerrigan的第一次尝试
*/
public class SingletonKerriganA {
/**
* 单例对象实例
*/
private static SingletonKerriganA instance = null;
public static SingletonKerriganA getInstance() {
if (instance == null) { //line A
instance = new SingletonKerriganA(); //line B
}
return instance;
}
}
/**
* 实现单例访问Kerrigan的第一次尝试
*/
public class SingletonKerriganA {
/**
* 单例对象实例
*/
private static SingletonKerriganA instance = null;
public static SingletonKerriganA getInstance() {
if (instance == null) { //line A
instance = new SingletonKerriganA(); //line B
}
return instance;
}
}
这个写法我们把四点需求从上往下检测,发现第二点的时候就出了问题,假设这样的场景:两个线程并发调用SingletonKerriganA.getInstance(),假设线程一先判断完instance是否为null,既代码中的line A进入到line B的位置。刚刚判断完毕后,JVM将CPU资源切换给线程二,由于线程一还没执行line B,所以instance仍然是空的,因此线程二执行了new SignletonKerriganA()操作。片刻之后,线程一被重新唤醒,它执行的仍然是new SignletonKerriganA()操作,好了,问题来了,两个Kerrigan谁是李逵谁是李鬼?
紧接着,我们做单例模式的第二次尝试:
Java代码
/**
* 实现单例访问Kerrigan的第二次尝试
*/
public class SingletonKerriganB {
/**
* 单例对象实例
*/
private static SingletonKerriganB instance = null;
public synchronized static SingletonKerriganB getInstance() {
if (instance == null) {
instance = new SingletonKerriganB();
}
return instance;
}
}
/**
* 实现单例访问Kerrigan的第二次尝试
*/
public class SingletonKerriganB {
/**
* 单例对象实例
*/
private static SingletonKerriganB instance = null;
public synchronized static SingletonKerriganB getInstance() {
if (instance == null) {
instance = new SingletonKerriganB();
}
return instance;
}
}
比起第一段代码仅仅在方法中多了一个synchronized修饰符,现在可以保证不会出线程问题了。但是这里有个很大(至少耗时比例上很大)的性能问题。除了第一次调用时是执行了SingletonKerriganB的构造函数之外,以后的每一次调用都是直接返回instance对象。返回对象这个操作耗时是很小的,绝大部分的耗时都用在synchronized修饰符的同步准备上,因此从性能上说很不划算。
那继续把代码改成下面的样子:
Java代码
/**
* 实现单例访问Kerrigan的第三次尝试
*/
public class SingletonKerriganC {
/**
* 单例对象实例
*/
private static SingletonKerriganC instance = null;
public static SingletonKerriganC getInstance() {
synchronized (SingletonKerriganC.class) {
if (instance == null) {
instance = new SingletonKerriganC();
}
}
return instance;
}
}
/**
* 实现单例访问Kerrigan的第三次尝试
*/
public class SingletonKerriganC {
/**
* 单例对象实例
*/
private static SingletonKerriganC instance = null;
public static SingletonKerriganC getInstance() {
synchronized (SingletonKerriganC.class) {
if (instance == null) {
instance = new SingletonKerriganC();
}
}
return instance;
}
}
基本上,把synchronized移动到代码内部是没有什么意义的,每次调用getInstance()还是要进行同步。同步本身没有问题,但是我们只希望在第一次创建Kerrigan实例的时候进行同步,因此我们有了下面的写法——双重锁定检查(DCL)。
Java代码
/**
* 实现单例访问Kerrigan的第四次尝试
*/
public class SingletonKerriganD {
/**
* 单例对象实例
*/
private static SingletonKerriganD instance = null;
public static SingletonKerriganD getInstance() {
if (instance == null) {
synchronized (SingletonKerriganD.class) {
if (instance == null) {
instance = new SingletonKerriganD();
}
}
}
return instance;
}
}
/**
* 实现单例访问Kerrigan的第四次尝试
*/
public class SingletonKerriganD {
/**
* 单例对象实例
*/
private static SingletonKerriganD instance = null;
public static SingletonKerriganD getInstance() {
if (instance == null) {
synchronized (SingletonKerriganD.class) {
if (instance == null) {
instance = new SingletonKerriganD();
}
}
}
return instance;
}
}
看起来这样已经达到了我们的要求,除了第一次创建对象之外,其他的访问在第一个if中就返回了,因此不会走到同步块中。已经完美了吗?
我们来看看这个场景:假设线程一执行到instance = new SingletonKerriganD()这句,这里看起来是一句话,但实际上它并不是一个原子操作(原子操作的意思就是这条语句要么就被执行完,要么就没有被执行过,不能出现执行了一半这种情形)。事实上高级语言里面非原子操作有很多,我们只要看看这句话被编译后在JVM执行的对应汇编代码就发现,这句话被编译成8条汇编指令,大致做了3件事情:
1.给Kerrigan的实例分配内存。
2.初始化Kerrigan的构造器
3.将instance对象指向分配的内存空间(注意到这步instance就非null了)。
但是,由于Java编译器允许处理器乱序执行(out-of-order),以及JDK1.5之前JMM(Java Memory Medel)中Cache、寄存器到主内存回写顺序的规定,上面的第二点和第三点的顺序是无法保证的,也就是说,执行顺序可能是1-2-3也可能是1-3-2,如果是后者,并且在3执行完毕、2未执行之前,被切换到线程二上,这时候instance因为已经在线程一内执行过了第三点,instance已经是非空了,所以线程二直接拿走instance,然后使用,然后顺理成章地报错,而且这种难以跟踪难以重现的错误估计调试上一星期都未必能找得出来,真是一茶几的杯具啊。
DCL的写法来实现单例是很多技术书、教科书(包括基于JDK1.4以前版本的书籍)上推荐的写法,实际上是不完全正确的。的确在一些语言(譬如C语言)上DCL是可行的,取决于是否能保证2、3步的顺序。在JDK1.5之后,官方已经注意到这种问题,因此调整了JMM、具体化了volatile关键字,因此如果JDK是1.5或之后的版本,只需要将instance的定义改成“private volatile static SingletonKerriganD instance = null;”就可以保证每次都去instance都从主内存读取,就可以使用DCL的写法来完成单例模式。当然volatile或多或少也会影响到性能,最重要的是我们还要考虑JDK1.42以及之前的版本,所以本文中单例模式写法的改进还在继续。
代码倒越来越复杂了,现在先来个返璞归真,根据JLS(Java Language Specification)中的规定,一个类在一个ClassLoader中只会被初始化一次,这点是JVM本身保证的,那就把初始化实例的事情扔给JVM好了,代码被改成这样:
Java代码
/**
* 实现单例访问Kerrigan的第五次尝试
*/
public class SingletonKerriganE {
/**
* 单例对象实例
*/
private static SingletonKerriganE instance = new SingletonKerriganE();
public static SingletonKerriganE getInstance() {
return instance;
}
}
/**
* 实现单例访问Kerrigan的第五次尝试
*/
public class SingletonKerriganE {
/**
* 单例对象实例
*/
private static SingletonKerriganE instance = new SingletonKerriganE();
public static SingletonKerriganE getInstance() {
return instance;
}
}
好吧,如果这种写法是完美的话,那前面那么几大段话就是作者在消遣各位读者。这种写法不会出现并发问题,但是它是饿汉式的,在ClassLoader加载类后Kerrigan的实例就会第一时间被创建,饿汉式的创建方式在一些场景中将无法使用:譬如Kerrigan实例的创建是依赖参数或者配置文件的,在getInstance()之前必须调用某个方法设置参数给它,那样这种单例写法就无法使用了。
再来看看下面这种我觉得能应对较多场景的单例写法:
Java代码
/**
* 实现单例访问Kerrigan的第六次尝试
*/
public class SingletonKerriganF {
private static class SingletonHolder {
/**
* 单例对象实例
*/
static final SingletonKerriganF INSTANCE = new SingletonKerriganF();
}
public static SingletonKerriganF getInstance() {
return SingletonHolder.INSTANCE;
}
}
/**
* 实现单例访问Kerrigan的第六次尝试
*/
public class SingletonKerriganF {
private static class SingletonHolder {
/**
* 单例对象实例
*/
static final SingletonKerriganF INSTANCE = new SingletonKerriganF();
}
public static SingletonKerriganF getInstance() {
return SingletonHolder.INSTANCE;
}
}
这种写法仍然使用JVM本身机制保证了线程安全问题;由于SingletonHolder是私有的,除了getInstance()之外没有办法访问它,因此它是懒汉式的;同时读取实例的时候不会进行同步,没有性能缺陷;也不依赖JDK版本。
其他单例模式的写法还有很多,如使用本地线程(ThreadLocal)来处理并发以及保证一个线程内一个单例的实现、GoF原始例子中使用注册方式应对单例类需要需要继承时的实现、使用指定类加载器去应对多ClassLoader环境下的实现等等。我们做开发设计工作的时,应当既要考虑到需求可能出现的扩展与变化,也应当避免“幻影需求”导致无谓的提升设计、实现复杂度,最终反而带来工期、性能和稳定性的损失。设计不足与设计过度都是危害,所以说没有最好的单例模式,只有最合适的单例模式。
到这里为止,单例模式本身就先告一段落了,最后在介绍从其他途径屏蔽构造单例对象的方法:
1.直接new单例对象
2.通过反射构造单例对象
3.通过序列化构造单例对象。
对于第一种情况,一般我们会加入一个private或者protected的构造函数,这样系统就不会自动添加那个public的构造函数了,因此只能调用里面的static方法,无法通过new创建对象。
对于第二种情况,反射时可以使用setAccessible方法来突破private的限制,我们需要做到第一点工作的同时,还需要在在 ReflectPermission("suppressAccessChecks") 权限下使用安全管理器(SecurityManager)的checkPermission方法来限制这种突破。一般来说,不会真的去做这些事情,都是通过应用服务器进行后台配置实现。
对于第三种情况,如果单例对象有必要实现Serializable接口(很少出现),则应当同时实现readResolve()方法来保证反序列化的时候得到原来的对象。
基于上述情况,将单例模式增加两个方法:
Java代码
/**
* 能应对大多数情况的单例实现
*/
public class SingletonKerrigan implements Serializable {
private static class SingletonHolder {
/**
* 单例对象实例
*/
static final SingletonKerrigan INSTANCE = new SingletonKerrigan();
}
public static SingletonKerrigan getInstance() {
return SingletonHolder.INSTANCE;
}
/**
* private的构造函数用于避免外界直接使用new来实例化对象
*/
private SingletonKerrigan() {
}
/**
* readResolve方法应对单例对象被序列化时候
*/
private Object readResolve() {
return getInstance();
}
}
/**
* 能应对大多数情况的单例实现
*/
public class SingletonKerrigan implements Serializable {
private static class SingletonHolder {
/**
* 单例对象实例
*/
static final SingletonKerrigan INSTANCE = new SingletonKerrigan();
}
public static SingletonKerrigan getInstance() {
return SingletonHolder.INSTANCE;
}
/**
* private的构造函数用于避免外界直接使用new来实例化对象
*/
private SingletonKerrigan() {
}
/**
* readResolve方法应对单例对象被序列化时候
*/
private Object readResolve() {
return getInstance();
}
}
总结:
本章通过一次次的的尝试,去了解单例模式各种实现方案的优缺点。对双锁锁定检测进行了简单的讨论,相信大家能从各种尝试的演化过程中,明白为何单例模式是最简单而又最复杂的一种构造模式。
各种构造模式之间可以互相比较,但是没有优劣好坏之分,只有确定了上下文环境,才能谈应用什么模式。学习设计模式我觉得也没有必要去强背一些代码模版,应当去理解每种模式的出现的原因和解决的问题,当你发现你的设计需要更大灵活性时,设计便会向着合适的模式演化,这时候你就真正的掌握了设计模式。
前面说提到的五种创建模式,主要解决的问题是如何创建对象,获得产品。而单例模式最要关心的则是对象创建的次数以及何时被创建。
Singleton模式可以是很简单的,它的全部只需要一个类就可以完成(看看这章可怜的UML图)。但是如果在“对象创建的次数以及何时被创建”这两点上较真起来,Singleton模式可以相当的复杂,比头五种模式加起来还复杂,譬如涉及到DCL双锁检测(double checked locking)的讨论、涉及到多个类加载器(ClassLoader)协同时、涉及到跨JVM(集群、远程EJB等)时、涉及到单例对象被销毁后重建等。对于复杂的情况,本章中会涉及到其中一些[1]
目的:
希望对象只创建一个实例,并且提供一个全局的访问点。
场景:
Kerrigan对于Zerg来说是个至关重要的灵魂人物,无数的Drone、Zergling、Hydralisk……可以被创造、被牺牲,但是Kerrigan得存在关系到Zerg在这局游戏中的生存,而且Kerrigan是不允许被多次创造的,必须有且只有一个虫族刀锋女王的实例存在,这不是游戏规则,但这是个政治问题。
分析:
如前面一样,我们还是尝试使用代码来描述访问Kerrigan的过程,看看下面的UML图,简单得我都不怎么好意思放上来占版面。
图6.1 单例模式的UML图
结构是简单的,只是我们还有一些小小的要求如下:
1.最基本要求:每次从getInstance()都能返回一个且唯一的一个Kerrigan对象。
2.稍微高一点的要求:Kerrigan很忙,很多人找,所以希望这个方法能适应多线程并发访问。
3.再提高一点的要求:Zerg是讲究公务员效率的社会,希望找Kerrigan的方法性能尽可能高。
4.最后一点要求是Kerrigan自己提出的:体谅到Kerrigan太累,希望多些睡觉时间,因此Kerrigan希望实现懒加载(Lazy Load),在需要的时候才被构造。
5.原本打算说还提要处理多ClassLoader、多JVM等情况,不过还是不要把情况考虑的太复杂了,暂且先放过作者吧(-_-#)。
我们第一次写的单例模式是下面这个样子的:
Java代码
/**
* 实现单例访问Kerrigan的第一次尝试
*/
public class SingletonKerriganA {
/**
* 单例对象实例
*/
private static SingletonKerriganA instance = null;
public static SingletonKerriganA getInstance() {
if (instance == null) { //line A
instance = new SingletonKerriganA(); //line B
}
return instance;
}
}
/**
* 实现单例访问Kerrigan的第一次尝试
*/
public class SingletonKerriganA {
/**
* 单例对象实例
*/
private static SingletonKerriganA instance = null;
public static SingletonKerriganA getInstance() {
if (instance == null) { //line A
instance = new SingletonKerriganA(); //line B
}
return instance;
}
}
这个写法我们把四点需求从上往下检测,发现第二点的时候就出了问题,假设这样的场景:两个线程并发调用SingletonKerriganA.getInstance(),假设线程一先判断完instance是否为null,既代码中的line A进入到line B的位置。刚刚判断完毕后,JVM将CPU资源切换给线程二,由于线程一还没执行line B,所以instance仍然是空的,因此线程二执行了new SignletonKerriganA()操作。片刻之后,线程一被重新唤醒,它执行的仍然是new SignletonKerriganA()操作,好了,问题来了,两个Kerrigan谁是李逵谁是李鬼?
紧接着,我们做单例模式的第二次尝试:
Java代码
/**
* 实现单例访问Kerrigan的第二次尝试
*/
public class SingletonKerriganB {
/**
* 单例对象实例
*/
private static SingletonKerriganB instance = null;
public synchronized static SingletonKerriganB getInstance() {
if (instance == null) {
instance = new SingletonKerriganB();
}
return instance;
}
}
/**
* 实现单例访问Kerrigan的第二次尝试
*/
public class SingletonKerriganB {
/**
* 单例对象实例
*/
private static SingletonKerriganB instance = null;
public synchronized static SingletonKerriganB getInstance() {
if (instance == null) {
instance = new SingletonKerriganB();
}
return instance;
}
}
比起第一段代码仅仅在方法中多了一个synchronized修饰符,现在可以保证不会出线程问题了。但是这里有个很大(至少耗时比例上很大)的性能问题。除了第一次调用时是执行了SingletonKerriganB的构造函数之外,以后的每一次调用都是直接返回instance对象。返回对象这个操作耗时是很小的,绝大部分的耗时都用在synchronized修饰符的同步准备上,因此从性能上说很不划算。
那继续把代码改成下面的样子:
Java代码
/**
* 实现单例访问Kerrigan的第三次尝试
*/
public class SingletonKerriganC {
/**
* 单例对象实例
*/
private static SingletonKerriganC instance = null;
public static SingletonKerriganC getInstance() {
synchronized (SingletonKerriganC.class) {
if (instance == null) {
instance = new SingletonKerriganC();
}
}
return instance;
}
}
/**
* 实现单例访问Kerrigan的第三次尝试
*/
public class SingletonKerriganC {
/**
* 单例对象实例
*/
private static SingletonKerriganC instance = null;
public static SingletonKerriganC getInstance() {
synchronized (SingletonKerriganC.class) {
if (instance == null) {
instance = new SingletonKerriganC();
}
}
return instance;
}
}
基本上,把synchronized移动到代码内部是没有什么意义的,每次调用getInstance()还是要进行同步。同步本身没有问题,但是我们只希望在第一次创建Kerrigan实例的时候进行同步,因此我们有了下面的写法——双重锁定检查(DCL)。
Java代码
/**
* 实现单例访问Kerrigan的第四次尝试
*/
public class SingletonKerriganD {
/**
* 单例对象实例
*/
private static SingletonKerriganD instance = null;
public static SingletonKerriganD getInstance() {
if (instance == null) {
synchronized (SingletonKerriganD.class) {
if (instance == null) {
instance = new SingletonKerriganD();
}
}
}
return instance;
}
}
/**
* 实现单例访问Kerrigan的第四次尝试
*/
public class SingletonKerriganD {
/**
* 单例对象实例
*/
private static SingletonKerriganD instance = null;
public static SingletonKerriganD getInstance() {
if (instance == null) {
synchronized (SingletonKerriganD.class) {
if (instance == null) {
instance = new SingletonKerriganD();
}
}
}
return instance;
}
}
看起来这样已经达到了我们的要求,除了第一次创建对象之外,其他的访问在第一个if中就返回了,因此不会走到同步块中。已经完美了吗?
我们来看看这个场景:假设线程一执行到instance = new SingletonKerriganD()这句,这里看起来是一句话,但实际上它并不是一个原子操作(原子操作的意思就是这条语句要么就被执行完,要么就没有被执行过,不能出现执行了一半这种情形)。事实上高级语言里面非原子操作有很多,我们只要看看这句话被编译后在JVM执行的对应汇编代码就发现,这句话被编译成8条汇编指令,大致做了3件事情:
1.给Kerrigan的实例分配内存。
2.初始化Kerrigan的构造器
3.将instance对象指向分配的内存空间(注意到这步instance就非null了)。
但是,由于Java编译器允许处理器乱序执行(out-of-order),以及JDK1.5之前JMM(Java Memory Medel)中Cache、寄存器到主内存回写顺序的规定,上面的第二点和第三点的顺序是无法保证的,也就是说,执行顺序可能是1-2-3也可能是1-3-2,如果是后者,并且在3执行完毕、2未执行之前,被切换到线程二上,这时候instance因为已经在线程一内执行过了第三点,instance已经是非空了,所以线程二直接拿走instance,然后使用,然后顺理成章地报错,而且这种难以跟踪难以重现的错误估计调试上一星期都未必能找得出来,真是一茶几的杯具啊。
DCL的写法来实现单例是很多技术书、教科书(包括基于JDK1.4以前版本的书籍)上推荐的写法,实际上是不完全正确的。的确在一些语言(譬如C语言)上DCL是可行的,取决于是否能保证2、3步的顺序。在JDK1.5之后,官方已经注意到这种问题,因此调整了JMM、具体化了volatile关键字,因此如果JDK是1.5或之后的版本,只需要将instance的定义改成“private volatile static SingletonKerriganD instance = null;”就可以保证每次都去instance都从主内存读取,就可以使用DCL的写法来完成单例模式。当然volatile或多或少也会影响到性能,最重要的是我们还要考虑JDK1.42以及之前的版本,所以本文中单例模式写法的改进还在继续。
代码倒越来越复杂了,现在先来个返璞归真,根据JLS(Java Language Specification)中的规定,一个类在一个ClassLoader中只会被初始化一次,这点是JVM本身保证的,那就把初始化实例的事情扔给JVM好了,代码被改成这样:
Java代码
/**
* 实现单例访问Kerrigan的第五次尝试
*/
public class SingletonKerriganE {
/**
* 单例对象实例
*/
private static SingletonKerriganE instance = new SingletonKerriganE();
public static SingletonKerriganE getInstance() {
return instance;
}
}
/**
* 实现单例访问Kerrigan的第五次尝试
*/
public class SingletonKerriganE {
/**
* 单例对象实例
*/
private static SingletonKerriganE instance = new SingletonKerriganE();
public static SingletonKerriganE getInstance() {
return instance;
}
}
好吧,如果这种写法是完美的话,那前面那么几大段话就是作者在消遣各位读者。这种写法不会出现并发问题,但是它是饿汉式的,在ClassLoader加载类后Kerrigan的实例就会第一时间被创建,饿汉式的创建方式在一些场景中将无法使用:譬如Kerrigan实例的创建是依赖参数或者配置文件的,在getInstance()之前必须调用某个方法设置参数给它,那样这种单例写法就无法使用了。
再来看看下面这种我觉得能应对较多场景的单例写法:
Java代码
/**
* 实现单例访问Kerrigan的第六次尝试
*/
public class SingletonKerriganF {
private static class SingletonHolder {
/**
* 单例对象实例
*/
static final SingletonKerriganF INSTANCE = new SingletonKerriganF();
}
public static SingletonKerriganF getInstance() {
return SingletonHolder.INSTANCE;
}
}
/**
* 实现单例访问Kerrigan的第六次尝试
*/
public class SingletonKerriganF {
private static class SingletonHolder {
/**
* 单例对象实例
*/
static final SingletonKerriganF INSTANCE = new SingletonKerriganF();
}
public static SingletonKerriganF getInstance() {
return SingletonHolder.INSTANCE;
}
}
这种写法仍然使用JVM本身机制保证了线程安全问题;由于SingletonHolder是私有的,除了getInstance()之外没有办法访问它,因此它是懒汉式的;同时读取实例的时候不会进行同步,没有性能缺陷;也不依赖JDK版本。
其他单例模式的写法还有很多,如使用本地线程(ThreadLocal)来处理并发以及保证一个线程内一个单例的实现、GoF原始例子中使用注册方式应对单例类需要需要继承时的实现、使用指定类加载器去应对多ClassLoader环境下的实现等等。我们做开发设计工作的时,应当既要考虑到需求可能出现的扩展与变化,也应当避免“幻影需求”导致无谓的提升设计、实现复杂度,最终反而带来工期、性能和稳定性的损失。设计不足与设计过度都是危害,所以说没有最好的单例模式,只有最合适的单例模式。
到这里为止,单例模式本身就先告一段落了,最后在介绍从其他途径屏蔽构造单例对象的方法:
1.直接new单例对象
2.通过反射构造单例对象
3.通过序列化构造单例对象。
对于第一种情况,一般我们会加入一个private或者protected的构造函数,这样系统就不会自动添加那个public的构造函数了,因此只能调用里面的static方法,无法通过new创建对象。
对于第二种情况,反射时可以使用setAccessible方法来突破private的限制,我们需要做到第一点工作的同时,还需要在在 ReflectPermission("suppressAccessChecks") 权限下使用安全管理器(SecurityManager)的checkPermission方法来限制这种突破。一般来说,不会真的去做这些事情,都是通过应用服务器进行后台配置实现。
对于第三种情况,如果单例对象有必要实现Serializable接口(很少出现),则应当同时实现readResolve()方法来保证反序列化的时候得到原来的对象。
基于上述情况,将单例模式增加两个方法:
Java代码
/**
* 能应对大多数情况的单例实现
*/
public class SingletonKerrigan implements Serializable {
private static class SingletonHolder {
/**
* 单例对象实例
*/
static final SingletonKerrigan INSTANCE = new SingletonKerrigan();
}
public static SingletonKerrigan getInstance() {
return SingletonHolder.INSTANCE;
}
/**
* private的构造函数用于避免外界直接使用new来实例化对象
*/
private SingletonKerrigan() {
}
/**
* readResolve方法应对单例对象被序列化时候
*/
private Object readResolve() {
return getInstance();
}
}
/**
* 能应对大多数情况的单例实现
*/
public class SingletonKerrigan implements Serializable {
private static class SingletonHolder {
/**
* 单例对象实例
*/
static final SingletonKerrigan INSTANCE = new SingletonKerrigan();
}
public static SingletonKerrigan getInstance() {
return SingletonHolder.INSTANCE;
}
/**
* private的构造函数用于避免外界直接使用new来实例化对象
*/
private SingletonKerrigan() {
}
/**
* readResolve方法应对单例对象被序列化时候
*/
private Object readResolve() {
return getInstance();
}
}
总结:
本章通过一次次的的尝试,去了解单例模式各种实现方案的优缺点。对双锁锁定检测进行了简单的讨论,相信大家能从各种尝试的演化过程中,明白为何单例模式是最简单而又最复杂的一种构造模式。
各种构造模式之间可以互相比较,但是没有优劣好坏之分,只有确定了上下文环境,才能谈应用什么模式。学习设计模式我觉得也没有必要去强背一些代码模版,应当去理解每种模式的出现的原因和解决的问题,当你发现你的设计需要更大灵活性时,设计便会向着合适的模式演化,这时候你就真正的掌握了设计模式。
发表评论
-
Java编程中“为了性能”尽量要做到的一些地方
2012-07-04 14:44 6431.慎用synchronized,尽量减小synchroniz ... -
利用Session防止表单重复提交
2011-12-13 18:36 11701 由于服务器缓慢或者 ... -
java format(MessageFormat)
2011-12-06 17:20 764java.text.Format |__java. ... -
java 主线程等待子线程执行完成后再执行
2011-12-06 09:47 3344原文:http://www.jiacheo.org/blog ... -
Ognl/MVEL/Aviator/JSEL 四种表达式引擎执行效率对比
2011-11-24 10:33 2996http://jindw.iteye.com/blog/732 ... -
java模拟javascript的encodeURI方法
2011-10-27 15:52 2933import java.io.UnsupportedEncod ... -
3种下载文件程序的思考,为何使用NIO进行异步网络通讯
2011-10-08 14:37 685原文链接:http://suhuanzheng7784877 ... -
cglib 动态代理
2011-08-12 10:35 737cglib is a powerful, high perfo ... -
【温故而知新】log4j输出多个自定义日志文件,动态配置路径
2011-08-10 15:38 8651. log4j输出多个自定义日志文件 log ... -
java7 新特性
2011-08-10 10:48 721原文链接:http://www.iteye ... -
Java版短网址(ShortUrl)的算法
2011-06-09 10:42 2745最近,我的项目中需要用到短网址(ShortUrl)的算法,于是 ... -
设计模式学习——适配器模式
2011-06-07 10:30 747某个类拥有我们所 ... -
用spring做一个javaMail功能的例子
2011-05-16 09:37 1216前言:项目中要做一个发送邮件的功能,在网上搜了一些代码,说的都 ... -
UML中几种类间关系:继承、实现、依赖、关联、聚合、组合的联系与区别
2010-10-14 18:38 866今天看到一篇好文,觉得还不错,褪去的记忆被唤醒:http:/ ... -
动态代理
2010-07-13 11:11 734http://www.iteye.com/topic/7103 ... -
ASCLL,Unicode 和 UTF-8
2010-05-15 13:36 14591.Ascll 算是比较早的编码,七位二进制数表示,当然在 ... -
String 详解
2010-05-12 10:29 794解析Java中的String对象的数据类型 1. 首先S ... -
判断数据的类型
2010-05-04 15:24 821// 字符类型 String if (pramets.get( ... -
关于ThreadLocal模式的体会
2010-03-18 11:00 1198本文转至::http://www.iteye.com/topi ... -
javaClassLoader类加载器详解<转>
2010-03-12 14:43 1033由于一个JDBC的基本封装 ...
相关推荐
李建忠老师的设计模式-单例模式讲解,示例以C++编程语言呈现。
在Java编程语言中,设计模式是一种经过验证的解决常见软件设计问题的最佳实践。单例模式是其中最常用的一种,它的核心思想是确保一个类只有一个实例,并提供全局访问点。单例模式的应用场景包括:控制资源的访问、...
设计模式-单例模式脑图
JAVA-设计模式-创建型模式-单例模式
Java设计模式-单例模式详解 单例模式是 Java 设计模式中的一种常用的设计模式,旨在保证一个类仅有一个实例,并提供一个访问它的全局访问点。单例模式的目的是为了保证在一个进程中,某个类有且仅有一个实例。 ...
ava常用设计模式-单例模式 单例模式(Singleton Pattern)是 Java 中最简单的设计模式之一,有以下特点: 1. 单例类只能有一个实例。 2. 单例类必须自己创建自己的唯一实例。 3. 单例类必须给所有其他对象提供这一...
设计模式-单例模式 单例模式是一种常见的设计模式,它的主要作用是确保在内存中仅创建一次对象,并提供一个全局访问点。单例模式有两种类型:饿汉类型和懒汉类型。 饿汉类型的单例模式是在类加载时创建对象,例如...
本资源“一例读懂设计模式-单例模式、简单工厂模式.zip”旨在帮助初学者通过实例深入理解这两种重要设计模式:单例模式和简单工厂模式。以下是关于这两个模式的详细讲解。 1. **单例模式**: 单例模式是一种限制类...
**设计模式——单例模式** 单例模式是一种广泛应用于软件设计中的创建型设计模式,它的核心思想是确保一个类只有一个实例,并提供一个全局访问点。这样做的好处在于控制共享资源的访问,比如线程安全的数据库连接池...
android 单例模式 干货 告诉你哪种单例模式最实用 最好用 不再迷茫
单例模式是一种常见的创建型设计模式,其核心思想在于确保一个类仅有一个实例存在,并且该实例由该类自行创建,随后向整个系统提供这一唯一实例。 #### 类图解析 在设计模式中,类图是一种直观展示类结构及关系的...
单例模式是一种常用的设计模式,它在软件工程中扮演着控制类实例化过程的角色,确保一个类只有一个实例,并提供全局访问点。这种模式在PHP中尤其常见,特别是在需要频繁实例化然后销毁的对象,或者需要控制共享资源...
在iOS开发中,设计模式是解决常见编程问题的模板,为代码组织提供了标准结构。其中,单例模式是一种被广泛使用的模式,它确保一个类在整个应用程序中只有一个实例,并且提供了一个全局访问点来获取这个实例。这样的...
### Java设计模式——单例模式详解 #### 一、单例模式概述 单例模式是设计模式中的一个重要组成部分,属于创建型模式之一。其主要作用是确保某个类仅有一个实例存在,并提供一个全局访问该实例的方法。这在很多场景...
**单例模式**是软件设计模式中的一种,属于创建型模式。在C++中,单例模式确保一个类只有一个实例,并提供一个全局访问点。这种模式通常用于管理共享资源,如数据库连接、日志系统或者配置文件等。单例模式的主要...
单例模式是软件设计模式中的一种经典模式,它在Java编程中被广泛使用。这个模式的主要目的是确保一个类只有一个实例,并提供一个全局访问点。这样做的好处在于可以控制实例的数量,减少资源消耗,同时便于协调整个...
单例设计模式是一种常用的设计模式,其主要目的是确保一个类只有一个实例,并提供全局访问点。在Java中,实现单例模式通常有多种方式,包括懒汉模式、饿汉模式、静态内部类以及枚举类型。 1. **懒汉模式**: 懒汉...
单例模式是软件设计模式中的一种,它保证一个类只有一个实例,并提供全局访问点。这种模式在许多场景下非常有用,比如控制共享资源、管理系统级别的对象,如数据库连接池或者线程池等。单例模式的核心在于限制类的...
设计模式(Design pattern)代表了最佳的实践,通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段...