单列模式详解-java实现

2017-01-05 11:04:11来源:oschina作者:最帅的刘先生人点击

本篇文章摘自数据《漫谈设计模式》,看到了觉得好,就像分享给大家,是我辛辛苦苦一个字一个字敲上去的,大家喜欢就赞一个,又不好的希望大家留下评论,我一定改正。


一:最简单的单列

为了限制类的对象被随意的创建,需要保证该类的构造方法是私有的,这样外部类就无法创建该类型的对象了;另外,为了方面给客户对象提供此单列对象的使用,我们为它提供一个全局访问点,代码如下所示


public class Singleton {private static Singleton instance = new Singleton();private Singleton(){ }public static Singleton getInstance(){ return instance;} } 代码注解:


Singleton类只有一个构造方法,它是被Private修饰的,客户对象无法创建该类实例。


我们为此单列实现的全局访问点是public static Singleton getInstance()方法。


注意:instance变量是私有的,外界无法访问。


读者还可以定义instance变量是public,这样把属性直接暴露给其他对象,就没有必要实现public static Singleton getInstance()方法,但是可读性没有方法来的直接,而且把实例对象的名字直接暴露给客户程序,会增加代码的耦合度,如果改变此变量名称,就会引起客户类的改变。


还有一点,如果该实例需要比较复杂的初始化过程时,把这个程序因该写在static{...}静态代码块中。


此实现是线程安全的,当多个线程同时去访问该类的getInstance()方法时,不会初始化多个不同的对象,这是因为,JVM(java virtual machine)在加载此类时,对于static属性的初始化只能由一个线程执行且仅一次。


由于此单列提供了静态的公有方法,那么客户端使用单列模式的代码也就非常简单了,如下所示。


Singleton singleton = Singleton.getInstance();

二:单列进阶

如果处于性能方面的考虑,我们希望延迟实例化单列对象(Static属性在加载类时候就会被初始化),只有在第一次使用该类的实例时才去实列化,我们因该怎么办呢?


1:延迟创建

这个其实并不难做到,我们把单列的实列化过程移至getInstance()方法,而不再加载类的时候预先创建。当访问此方法时,首先判断该实列是不是已经被实列化过了,如果已经被初始化了,则直接返回这个对象的引用;否则,创建这个实列并初始化,最后返回这个对象的引用。代码片段如下所示:


public class UnThreadSafeSingleton {


public static UnThreadSafeSingleton getSingleton(){ if(null==instance) {instance = new UnThreadSafeSingleton(); } return instance;} }


我们使用这句if(null==instance)判断是否实列化完成了。此方法不是线程安全的,接下来我们将会讨论。


2:线程安全

上节我们创建了可延迟初始化的单列,然而不幸的是,在高并发的环境中,getInstance()方法返回了多个指向不同的该类实列,究竟是什么原因呢?我们针对此方法,给出两个线程并发访问getInstance()方法时的一种情况,如下所示。


Thread1Thread2


if(null==instance)if(nulll==instance)


instance = new UnThreadSafeSingelton();instance = new UnThreadSafeSingelton();


return instance; return instance;


如果这两个线程按照上述步骤执行,不难返现,在时刻1和2,由于还没有创建单列对象,Thread1和Thread2都会进入创建单列实列的代码块分别创建实列。在时刻3,Thread1创建了一个实列对象,但是Thread2此时已经无法知道,于是继续创建一个新的实列对象,导致这两个线程持有的实列并非为同一个。


更为糟糕的是,在没有自动内存回收机制的语言平台上运行这样的单列模式,例如C++编写此模式,因为我们认为创建了一个单列实列,忽略了其它线程所产生的对象,不会手动去回收它们,从而引起了内存泄露。


为了解决这个问题,我们给此方法添加synchronized关键字,代码如下。


public class ThreadSafeSingelton{


public static synchronized ThreadSafeSingelton getInstance(){


if(null==instance){


instance = newThreadSafeSingelton();


}


return instance;


}


}


这样,再多的线程访问都只会实列化一个单列对象。


3:Double-Check Locking 双重检验锁

上述途径虽然实现了多线程的安全访问,但是在多线程高并发访问的情况下,给此方法加上synchronized关键字会使得性能大不如从前。


我们仔细分析一下不难发现,使用synchronized关键字对整个getInstance()方法进行同步是没有必要的,我们只需保证实例化这个对象的那段逻辑被一个线程执行就可以了,而返回引用的那段代码是没有必要同步的。按照这个想法,代码片段大致如下所示。


public class DoubleCheckSingleton{private volatile static DoubleCheckSingleton instance = null;public static DoubleCheckSingleton getInstance(){ if(null==instance){//检验是否被创建synchronized (DoubleCheckSingleton.class){ //创建同步锁 if(null==instance){//再次检验是否被创建instance = new DoubleCheckSingleton();}}return instance; }} }


代码注解:


在getInstance()方法里面,首先判断此实列是否已经被创建了,如果还没有创建,首先使用synchronized同步实列化代码块。在同步代码块里面,还需要再次检验是否已经创建了此类的实列,这是因为:如果没有第二次检查,这时候有两个线程ThreadA和ThreadB同时进入该方法,他们都检测到了instance为null,不管哪一个线程先占据同步锁,并创建实列对象,都不会阻止另外一个线程继续进入实例化代码块重新创建实列对象,这样,同样会生成两个实列对象。所以,我们在同步代码块里,要进行第二次判断,判断该对象是否已经被创建。


属性instance是被volatile修饰的,因为volatile具有synchronized的可见性特点,也就是说线程能够自动发现volatile变量的最新值。这样,如果instance实列化成功,其它线程便能立即发现。


注意:此程序只有在java5及以上版本才能正常运行,在以前版本不能保证其正常运行,这是由于java平台的内存模式容许out-of-order writes引起的,假定有两个线程,Thread1和Thread2,它们执行以下步奏:


1、Thread1发现instance没有被实列化,它获得锁,并且实列化此对象,JVM容许在没有完全实列化完成时instance变量就指向此实列,因为这些步奏可以是out-of-order writes的,此时instance==null为false,之前的版本即使用volatile关键字修饰也无效。


2、在初始化完成之前,Thread2进入此方法,发现instance已经不为null了,Thread2便认为该实列初始化完成了,使用这个为完全初始化的实列对象,则很可能引起系统的崩溃。


4:Initialization on demand holder

要使用线程安全的延迟的单列初始化,我们还有一种方法,称为Initialization on demand holder模式,代码如下所示。


public class LazyLoadedSingleton{private LazyLoadedSingleton(){ }private static class LazyHolder{//holds the singleton class private static final LazyLoadedSingleton singletonInstance = new LazyLoadedSingleton();}public static LazyLoadedSingleton getInstance(){ return LazyHolder.singletonInstance;} }


当JVM加载LazyLoadedSingleton类时,由于该类没有static属性,所以加载完成后便即可返回。只有第一次调用getInstance()方法时,JVM才会加载LazyHolder类,由于它包含一个static属性singletonInstance,所以会首先初始化这个变量,根据前面的介绍,我们知道此过程并不会出现并发问题(JLS保证),这样即实现了一个既保证了线程安全又支持延迟加载的单列模式。

5:Singleton的序列化

如果单列类实现了Serializable接口,这时候要特别注意,因为在默认情况下,每次反序列化总会创建一个新的实列对象,这样一个系统会出现多个对象供使用。我们因该怎么办呢?


熟悉java序列化的读者可能知道,我们需要在readResolve()方法里做文章,此方法在反序列化完成之前被执行,我们在此方法里替换掉反序列化出来的那个新的实列,让其指向内存中的那个单列对象即可,代码实现如下。


public class SerialibleSingleton implements Serializable{private static final long serialVersionUID = -6099617126325157499L;static SerialibleSingleton singleton = new SerialibleSingleton();private SerialibleSingleton(){ }//this method is called immediately after an object of this class is deserialized.//this method return the singleton instanceprivate Object readResolve(){ return singleton;} }


方法readResolve()直接返回singleton单列,这样,我们在内存中始终保持了一个唯一的单列对象。


注:在分布式环境中,我们可能还需要考虑如何保证在整个应用(可能分布在不同JVM)只有一个实列。

最新文章

123

最新摄影

微信扫一扫

第七城市微信公众平台