[转帖]Java语言中单例模式的四种写法_Android, Python及开发编程讨论区_Weblogic技术|Tuxedo技术|中间件技术|Oracle论坛|JAVA论坛|Linux/Unix技术|hadoop论坛_联动北方技术论坛  
网站首页 | 关于我们 | 服务中心 | 经验交流 | 公司荣誉 | 成功案例 | 合作伙伴 | 联系我们 |
联动北方-国内领先的云技术服务提供商
»  游客             当前位置:  论坛首页 »  自由讨论区 »  Android, Python及开发编程讨论区 »
总帖数
1
每页帖数
101/1页1
返回列表
0
发起投票  发起投票 发新帖子
查看: 3251 | 回复: 0   主题: [转帖]Java语言中单例模式的四种写法        下一篇 
smile
注册用户
等级:少校
经验:889
发帖:70
精华:2
注册:2013-4-22
状态:离线
发送短消息息给smile 加好友    发送短消息息给smile 发消息
发表于: IP:您无权察看 2013-4-24 10:11:38 | [全部帖] [楼主帖] 楼主

作为设计模式理论中的Helloworld,相信学习java语言的人,都应该听说过单例模式。单例模式作为对象的一种创建模式,它的作用是确保某一个类在整个系统中只有一个实例,而且自行实例化并向整个系统提供这个实例。

由此可见,单例模式具有以下的特点:

  1. 单例类只能有一个实例。
  2. 单例类必须自己创建自己的唯一的实例。
  3. 单例类必须给所有其他对象提供这一实例。

由于Java语言的特点,使得单例模式在Java语言的实现上有自己的特点。这些特点主要表现在单例类如何将自己实例化。

饿汉式单例类

饿汉式单例类是在Java语言里实现起来最为简便的单例类。其源代码如下:

01publicclassEagerSingleton {


02


03/** 通过静态变量初始化的类实例 */


04privatestaticfinalEagerSingleton instance = newEagerSingleton();


05


06/**


07* 私有的默认构造子


08*/


09privateEagerSingleton() {


10}


11


12/**


13* 获取唯一类实例的静态工厂方法


14*


15* @return


16*/


17publicstaticEagerSingleton getInstance() {


18returninstance;


19}


20


21}


由Java语言类的初始化顺序可知,在这个类被加载时,静态变量会被初始化,此时类的私有构造子会被调用。这时候,单例类的唯一实例就被创建出来了。

Java语言中单例类的一个最重要的特点是类的构造子是私有的,从而避免外界使用构造子直接创建出任意多该类的实例。值得指出的是,由于构造子是私有的,因此该类不能被继承。

懒汉式单例类

与饿汉式单例类相同之处是,懒汉式单例类的构造子也是私有的。而与饿汉式单例类不同的是,懒汉式单例类在第一次被引用时将自己实例化。在懒汉式单例类被加载时,不会将自己实例化。其源代码如下所示:

01publicclassLazySingleton {


02


03/**


04* 此时静态变量不能声明为final,因为需要在工厂方法中对它进行实例化


05*/


06privatestaticLazySingleton instance;


07


08/**


09* 私有构造子,确保无法在类外实例化该类


10*/


11privateLazySingleton() {


12}


13


14/**


15* synchronized关键字解决多个线程的同步问题


16*/


17publicstaticsynchronizedLazySingleton getInstance() {


18if(instance == null) {


19instance = newLazySingleton();


20}


21returninstance;


22}


23


24}


静态工厂方法中synchronized关键字提供的同步是必须的,否则当多个线程同时访问该方法时,无法确保获得的总是同一个实例。然而我们也看到,在所有的代码路径中,虽然只有第一次引用的时候需要对instance变量进行实例化,但是synchronized同步机制要求所有的代码执行路径都必须先获取类锁。在并发访问比较低时,效果并不显著,但是当并发访问量上升时,这里有可能会成为并发访问的瓶颈。

如果本文言尽于此,那实在没什么写的必要,因为以上介绍的知识,你可以从任何一本介绍单例模式的书查得到。下面我们来看看,为了降低线程同步的开销,从懒汉式单例模式中引申出来的两种很有意思的单例模式写法。

延长初始化占位

这种单例模式的写法,是著名的《Java Concurrency in Practice》一书中介绍对象的安全发布时介绍的。我们先来看它的源代码。

01publicclassResourceFactory {


02


03privatestaticclassResourceHolder {


04publicstaticResource resource = newResource();


05}


06


07publicstaticResource getResource() {


08returnResourceHolder.resource;


09}


10


11}


要理解上面这种单例类的写法,你需要先学习一些关于Java虚拟机如何初始化一个类的知识。

在java虚拟机中,类从被加载到虚拟机内存中开始,到卸载出内存为止,它的整个生命周期包括了:加载(Loading)、验证(Verification)、准备(Preparation)、解析(Resolution)、初始化(Initialization)、使用(Using)和卸载(Unloading)七个阶段。其中,验证、准备和解析三个部分统称为连接(Linking)。

加载、验证、准备、初始化和卸载这五个阶段的顺序是确定的,类的加载过程必须按照这种顺序按部就班地开始,而解析阶段则不一定:它在某些情况下可以在初始化阶段之后再开始,这是为了支持Java语言的运行时绑定(也被称为动态绑定或晚期绑定)。

什么情况下需要开始类加载的第一个阶段:加载。虚拟机规范中并没有进行强制约束,这点可以交给虚拟机的具体实现来自由把握。但是对于初始化阶段,虚拟机规范则是严格规定了有且只有四种情况必须立即对类进行“初始化”(而加载、验证、准备自然需要在此之前开始):

1)遇到new、getstatic、putstatic或invokestatic这四条字节码指令时,如果类没有进行过初始化,则需要先触发其初始化。生成这四条字节码指令最常见的Java代码场景是:使用new关键字实例化对象的时候、读取或设置一个类的静态字段(被final修饰、已在编译期把结果放入常量池的静态字段除外)的时候,以及调用一个类的静态方法的时候。

2)使用java.lang.reflect包的方法对类进行反射调用的时候,如果类没有进行过初始化,则需要先触发其初始化。

3)当初始化一个类的时候,如果发现其父类还没有进行过初始化,则需要先触发其父类的初始化。

4)当虚拟机启动时,用户需要指定一个要执行的主类(包含main()方法的那个类),虚拟机会先初始化这个主类。

这四种场景中的行为称为对一个类进行主动引用,除此之外所有引用类的方式,都不会触发类的初始化,被称为被动引用。以下是三个例子:

1)通过子类引用父类的静态字段,不会导致子类初始化。

2)通过数组定义来引用类,不会触发此类的初始化。

3)常量在编译阶段会存入调用类的常量池,本质上没有直接引用到定义常量的类,因此不会触发定义常量的类的初始化。

(以上摘自《深入理解Java虚拟机》)

从上面介绍的知识可以知道,JVM将推迟ResourceHolder类的初始化,直到第一个代码访问路径调用getResource()方法。此时,由于ResourceHolder.resource是一个读取静态字段的主动引用,虚拟机将第一次加载ResourceHolder类,并且通过一个静态变量来初始化Resource实例。而其他访问getResource()方法的代码路径,并不需要同步。

不需要额外的同步,但是又能确保对象可见性的正确发布,这是由Java的虚拟机规范所决定的!上面这种单例模式的写法,体现出对虚拟机规范的深刻理解,实在是专家级别的写法。

用读写锁编写的单例模式

在阅读Struts2源码的时候,我发现一个有意思的单例类写法:LoggerFactory。这里和大家分享一下,先看一下源码。

01packagecom.opensymphony.xwork2.util.logging;


02


03importcom.opensymphony.xwork2.util.logging.jdk.JdkLoggerFactory;


04


05importjava.util.concurrent.locks.ReadWriteLock;


06importjava.util.concurrent.locks.ReentrantReadWriteLock;


07


08/**


09* Creates loggers. Static accessor will lazily try to decide on the best factory if none specified.


10*/


11publicabstractclassLoggerFactory {


12


13privatestaticfinalReadWriteLock lock = newReentrantReadWriteLock();


14privatestaticLoggerFactory factory;


15


16publicstaticvoidsetLoggerFactory(LoggerFactory factory) {


17lock.writeLock().lock();


18try{


19LoggerFactory.factory = factory;


20} finally{


21lock.writeLock().unlock();


22}


23


24}


25


26publicstaticLogger getLogger(Class<?> cls) {


27returngetLoggerFactory().getLoggerImpl(cls);


28}


29


30publicstaticLogger getLogger(String name) {


31returngetLoggerFactory().getLoggerImpl(name);


32}


33


34protectedstaticLoggerFactory getLoggerFactory() {


35lock.readLock().lock();


36try{


37if(factory != null) {


38returnfactory;


39}


40} finally{


41lock.readLock().unlock();


42}


43lock.writeLock().lock();


44try{


45if(factory == null) {


46try{


47Class.forName("org.apache.commons.logging.LogFactory");


48factory = newcom.opensymphony.xwork2.util.logging.commons.CommonsLoggerFactory();


49} catch(ClassNotFoundException ex) {


50// commons logging not found, falling back to jdk logging


51factory = newJdkLoggerFactory();


52}


53}


54returnfactory;


55}


56finally{


57lock.writeLock().unlock();


58}


59}


60


61protectedabstractLogger getLoggerImpl(Class<?> cls);


62


63protectedabstractLogger getLoggerImpl(String name);


64


65}



它是一个抽象类,来看一个具体的实现类:CommonsLoggerFactory。

01packagecom.opensymphony.xwork2.util.logging.commons;


02


03importcom.opensymphony.xwork2.util.logging.Logger;


04importcom.opensymphony.xwork2.util.logging.LoggerFactory;


05importorg.apache.commons.logging.LogFactory;


06


07/**


08* Creates commons-logging-backed loggers


09*/


10publicclassCommonsLoggerFactory extendsLoggerFactory {


11


12@Override


13protectedLogger getLoggerImpl(Class<?> cls) {


14returnnewCommonsLogger(LogFactory.getLog(cls));


15}


16


17@Override


18protectedLogger getLoggerImpl(String name) {


19returnnewCommonsLogger(LogFactory.getLog(name));


20}


21


22}


可以看到,在大多数的代码路径下,getLoggerFactory()方法用可重入的读锁来进行同步。只在第一次访问时,使用了可重入的写锁来进行同步,进行factory对象的初始化。因为在写锁还没释放的时候,任何读锁的获取都会被阻塞,这样就保证了所发布的factory对象的可见性。

这里的代码,很容易就可以被改造成一个单例模式的写法。通过非阻塞的读写锁,避免了懒汉式单例类中所有代码访问路径都必须先获得类锁的弊端。




赞(0)    操作        顶端 
总帖数
1
每页帖数
101/1页1
返回列表
发新帖子
请输入验证码: 点击刷新验证码
您需要登录后才可以回帖 登录 | 注册
技术讨论