设计模式感悟（二）--- 单例模式（Singleton Pattern）

单例模式是什么

 

       按照四人团的说法 Singleton 模式的意图是：

       保证一个类仅有一个实例，并且为该类提供一个的全局访问点。

 

       也就是说你希望在你的应用程序或系统中，只存在唯一的该类的实例。这句话隐含着两个意思：你不能通过一般情况下的 new 来创建和访问该实例，如果可以这样，那你 new 一下就会产生一个实例，那么从另一个方面来讲就是创建该类实例的责任要要由该类自己承担，这让我们想到了静态工厂方法（getInstance 之类获取当前类实例的方法）；要提供一个全局访问点，既然不能自己 new 一个总要提供一个访问该唯一实例的方法，这让我们想到了类方法和类变量。

    

       上述分析后，单例模式的意图和实现也就差不多有了轮廓了。

 

 

 

哪些场景需要单例模式

   

       1。在资源管理方面的经常使用单例模式

        比如打印机的 Printer Spooler 是单例模式，这样可以避免两个作业同时输出到打印机;

 

       2。从系统性能方面考虑使用单例模式

       实例的创建是需要消耗系统资源的，而且是费时的，重复的对象最后还需要垃圾回收器回收，更是加重了系统的负担。

 

 

 

如何实现单例模式

 

       在设计单例模式的时候，首先要确定何时实例化该类的实例。第一种选择是将该单例对象作为单例类的一个静态域实例化。示例如下：

      

package com.zhaipuhong.designpattern;

public class Singleton {
	private static Singleton singleton = new Singleton();  //私有的本单例类的静态域
	
	/**
	 * 私有的构造方法，阻止了用户通过此构造方法直接创建实例
	 */
	private Singleton(){}
	
	public Singleton getInstance(){
		return singleton;
	}
}

 

 

第二种情况，如果不希望提前创建单例对象，可以等到第一次使用该单例对象的时候再创建它。即惰性出初始化（lazy-initialize）。示例如下：

package com.zhaipuhong.designpattern;

public class LazySingleton {
	private static LazySingleton lazySingleton;  //私有的静态本单例域
	
	private LazySingleton(){ } //私有的构造方法
	
	public LazySingleton getInstance(){  //获取本单例的唯一实例
		if(lazySingleton == null){
			lazySingleton = new LazySingleton();  
		}
		return lazySingleton;
	}
}

 

        第二种方式存在的因为不仅仅是从一种语言技巧，是有实际需要的。当应用程序或系统在静态初始化阶段可能无法收集到足够的信息来实例化单例对象，有的需要等到运行时通过计算才能获得，这时候你就应该使用第二种方式。

 

        另外从系统性能和优化方面来讲，我更喜欢第二种方式，需要时再创建。

 

 

 

单例模式的扩展

 

        上述惰性单例模式在单线程环境是没有问题的。但是如果是在多线程环境必须小心了。在多线程环境，我们无法保证

一个方法能够持续执行到结束，其它线程的方法才开始。那么多个线程有可能在微小的时间段来同时尝试初始化单例类，此时他们都发现该单例实例尚为空。

 

        看起来我们需要对“检查单例对象是否已经被创建”进行同步，但是这样一来，所以的线程都必须等待这个检查过程的完成。这种同步会造成严重的性能瓶劲。示例代码如下：

package com.zhaipuhong.designpattern;

public class SyncSingleton {
	private static SyncSingleton syncSingleton;
	private static final Object classLock = SyncSingleton.class;  //同步琐
	
	private SyncSingleton(){}
	
	public SyncSingleton getInstance(){
		synchronized(classLock){
			if(syncSingleton == null)
				syncSingleton = new SyncSingleton();
		    return syncSingleton;
		}
	}
}

 

 

 

        另一种方法是我们在检查之后（if (instance == null)）再放置一些同步代码, 但是还是可能出现多个现成同时通过了检查。我们改进一下，检查之后，在同步代码中再检查一边，这样就是“双重锁定检查”模式了。它能将非必须的锁定优化掉。这里的同步检查最多发生一次。不会造成性能瓶劲。示例代码如下：

package com.zhaipuhong.designpattern;

public class DoubleCheckedLocking {
	private static DoubleCheckedLocking dcl;
	
	private DoubleCheckedLocking(){}
	
	private synchronized static void doSync(){
		if(dcl == null) 
			dcl = new DoubleCheckedLocking();
	}
	
	public DoubleCheckedLocking getInstance(){
		if(dcl == null)  //一重检查
			doSync();    //同步的二重检查
		return dcl;
	}
}

 

 

单例模式在 Java 中的应用

        1。Java Mail API 1.4.2 中的 javax.mail.Session;

package javax.mail;

...

public final class Session{
    
    ...
    
    private static Session defaultSession = null;

    private Session(Properties properties, Authenticator authenticator1)
    {
       ...
    }

    public static synchronized Session getDefaultInstance(Properties properties, Authenticator authenticator1)
    {
        if(defaultSession == null)
            defaultSession = new Session(properties, authenticator1);
        else
        if(defaultSession.authenticator != authenticator1 && (defaultSession.authenticator == null || authenticator1 == null || defaultSession.authenticator.getClass().getClassLoader() != authenticator1.getClass().getClassLoader()))
            throw new SecurityException("Access to default session denied");
        return defaultSession;
    }
		...
}

 

2。java.lang.Runtime

package java.lang;

...

public class Runtime {
    private static Runtime currentRuntime = new Runtime();
    
    public static Runtime getRuntime() { 
	      return currentRuntime;
    }

    /** Don't let anyone else instantiate this class */
    private Runtime() {}
    ...

}

 

 

总结

       单例模式的价值在于将类的职责集中在唯一的单例实例中。在多线程环境中我们要考虑线程的特点来管理、控制线程的行为，实现单例模式。