研磨设计模式之单例模式-3

3.3  延迟加载的思想

        单例模式的懒汉式实现方式体现了延迟加载的思想，什么是延迟加载呢？
        通俗点说，就是一开始不要加载资源或者数据，一直等，等到马上就要使用这个资源或者数据了，躲不过去了才加载，所以也称Lazy Load，不是懒惰啊，是“延迟加载”，这在实际开发中是一种很常见的思想，尽可能的节约资源。
        体现在什么地方呢？看如下代码：


 

3.4  缓存的思想

        单例模式的懒汉式实现还体现了缓存的思想，缓存也是实际开发中非常常见的功能。
        简单讲就是，如果某些资源或者数据会被频繁的使用，而这些资源或数据存储在系统外部，比如数据库、硬盘文件等，那么每次操作这些数据的时候都从数据库或者硬盘上去获取，速度会很慢，会造成性能问题。
        一个简单的解决方法就是：把这些数据缓存到内存里面，每次操作的时候，先到内存里面找，看有没有这些数据，如果有，那么就直接使用，如果没有那么就获取它，并设置到缓存中，下一次访问的时候就可以直接从内存中获取了。从而节省大量的时间，当然，缓存是一种典型的空间换时间的方案。
        缓存在单例模式的实现中怎么体现的呢？

 3.5  Java中缓存的基本实现

        引申一下，看看在Java开发中的缓存的基本实现，在Java中最常见的一种实现缓存的方式就是使用Map，基本的步骤是：

• 先到缓存里面查找，看看是否存在需要使用的数据
• 如果没有找到，那么就创建一个满足要求的数据，然后把这个数据设置回到缓存中，以备下次使用
• 如果找到了相应的数据，或者是创建了相应的数据，那就直接使用这个数据。
  

 还是看看示例吧，示例代码如下：

/**
 * Java中缓存的基本实现示例
 */
public class JavaCache {
	/**
	 * 缓存数据的容器，定义成Map是方便访问，直接根据Key就可以获取Value了
	 * key选用String是为了简单，方便演示
	 */
	private Map<String,Object> map = new HashMap<String,Object>();
	/**
	 * 从缓存中获取值
	 * @param key 设置时候的key值
	 * @return key对应的Value值
	 */
	public Object getValue(String key){
		//先从缓存里面取值
		Object obj = map.get(key);
		//判断缓存里面是否有值
		if(obj == null){
			//如果没有，那么就去获取相应的数据，比如读取数据库或者文件
			//这里只是演示，所以直接写个假的值
			obj = key+",value";
			//把获取的值设置回到缓存里面
			map.put(key, obj);
		}
		//如果有值了，就直接返回使用
		return obj;
	}
}

 

        这里只是缓存的基本实现，还有很多功能都没有考虑，比如缓存的清除，缓存的同步等等。当然，Java的缓存还有很多实现方式，也是非常复杂的，现在有很多专业的缓存框架，更多缓存的知识，这里就不再去讨论了。

 

3.6  利用缓存来实现单例模式

        其实应用Java缓存的知识，也可以变相实现Singleton模式，算是一个模拟实现吧。每次都先从缓存中取值，只要创建一次对象实例过后，就设置了缓存的值，那么下次就不用再创建了。
        虽然不是很标准的做法，但是同样可以实现单例模式的功能，为了简单，先不去考虑多线程的问题，示例代码如下：

/**
 * 使用缓存来模拟实现单例
 */
public class Singleton {
	/**
	 * 定义一个缺省的key值，用来标识在缓存中的存放
	 */
	private final static String DEFAULT_KEY = "One";
	/**
	 * 缓存实例的容器
	 */
	private static Map<String,Singleton> map = 
new HashMap<String,Singleton>();
	/**
	 * 私有化构造方法
	 */
	private Singleton(){
		//
	}
	public static Singleton getInstance(){
		//先从缓存中获取
		Singleton instance = (Singleton)map.get(DEFAULT_KEY);
		//如果没有，就新建一个，然后设置回缓存中
		if(instance==null){
			instance = new Singleton();
			map.put(DEFAULT_KEY, instance);
		}
		//如果有就直接使用
		return instance;
	}
}

 

        是不是也能实现单例所要求的功能呢？其实实现模式的方式有很多种，并不是只有模式的参考实现所实现的方式，上面这种也能实现单例所要求的功能，只不过实现比较麻烦，不是太好而已，但在后面扩展单例模式的时候会有用。
        另外，模式是经验的积累，模式的参考实现并不一定是最优的，对于单例模式，后面会给大家一些更好的实现方式。

3.7  单例模式的优缺点

 

1：时间和空间
        比较上面两种写法：懒汉式是典型的时间换空间，也就是每次获取实例都会进行判断，看是否需要创建实例，费判断的时间，当然，如果一直没有人使用的话，那就不会创建实例，节约内存空间。
        饿汉式是典型的空间换时间，当类装载的时候就会创建类实例，不管你用不用，先创建出来，然后每次调用的时候，就不需要再判断了，节省了运行时间。

2：线程安全
（1）从线程安全性上讲，不加同步的懒汉式是线程不安全的，比如说：有两个线程，一个是线程A，一个是线程B，它们同时调用getInstance方法，那就可能导致并发问题。如下示例：

 程序继续运行，两个线程都向前走了一步，如下：

 

可能有些朋友会觉得文字描述还是不够直观，再来画个图说明一下，如图4所示：

                                                       图4  懒汉式单例的线程问题示意图

        通过图4的分解描述，明显可以看出，当A、B线程并发的情况下，会创建出两个实例来，也就是单例的控制在并发情况下失效了。

（2）饿汉式是线程安全的，因为虚拟机保证了只会装载一次，在装载类的时候是不会发生并发的。

（3）如何实现懒汉式的线程安全呢？
        当然懒汉式也是可以实现线程安全的，只要加上synchronized即可，如下：

public static synchronized Singleton getInstance(){}

         但是这样一来，会降低整个访问的速度，而且每次都要判断，也确实是稍微慢点。那么有没有更好的方式来实现呢？

（4）双重检查加锁
        可以使用“双重检查加锁”的方式来实现，就可以既实现线程安全，又能够使性能不受到大的影响。那么什么是“双重检查加锁”机制呢？
        所谓双重检查加锁机制，指的是：并不是每次进入getInstance方法都需要同步，而是先不同步，进入方法过后，先检查实例是否存在，如果不存在才进入下面的同步块，这是第一重检查。进入同步块过后，再次检查实例是否存在，如果不存在，就在同步的情况下创建一个实例，这是第二重检查。这样一来，就只需要同步一次了，从而减少了多次在同步情况下进行判断所浪费的时间。
        双重检查加锁机制的实现会使用一个关键字volatile，它的意思是：被volatile修饰的变量的值，将不会被本地线程缓存，所有对该变量的读写都是直接操作共享内存,从而确保多个线程能正确的处理该变量。
        注意:在Java1.4及以前版本中，很多JVM对于volatile关键字的实现有问题，会导致双重检查加锁的失败，因此双重检查加锁的机制只能用在Java5及以上的版本。
        看看代码可能会更清楚些，示例代码如下：

public class Singleton {
	/**
	 * 对保存实例的变量添加volatile的修饰
	 */
	private volatile static Singleton instance = null;
	private Singleton(){	
	}
	public static  Singleton getInstance(){
		//先检查实例是否存在，如果不存在才进入下面的同步块
		if(instance == null){
			//同步块，线程安全的创建实例
			synchronized(Singleton.class){
				//再次检查实例是否存在，如果不存在才真的创建实例
				if(instance == null){
					instance = new Singleton();
				}
			}
		}
		return instance;
	}
}

 
        这种实现方式既可使实现线程安全的创建实例，又不会对性能造成太大的影响，它只是在第一次创建实例的时候同步，以后就不需要同步了，从而加快运行速度。
         提示：由于volatile关键字可能会屏蔽掉虚拟机中一些必要的代码优化，所以运行效率并不是很高，因此一般建议，没有特别的需要，不要使用。也就是说，虽然可以使用双重加锁机制来实现线程安全的单例，但并不建议大量采用，根据情况来选用吧。

 

 

 

 

未完待续

 

评论

23 楼 zxh603 2011-10-31  

我想用楼主给的双重检查加锁模式测试下效率问题，然后我自己写了以下代码
public class ThreadOne extends Thread {

@Override
public void run(){
long startTime = System.currentTimeMillis();
Singleton singleton = null;
for(int i=0;i<10000;i++){
singleton = Singleton.Instance();
System.out.println(Singleton.getCount()+" ThreadOne: "+singleton);
}
long endTime = System.currentTimeMillis();

System.out.println(endTime-startTime);
}
}
其中Singleton跟楼主的是一样的，但是我每次测试出来的endTime-startTime 都是不一样的，想问下各位和楼主，有没有好的测试时间的方法啊

22 楼 cherrycmd 2010-11-11  

牛人呀，辛苦了

21 楼 bugnuke 2010-09-28  

很符合中国人的理解方式，所以觉得很亲近，看起来舒服很多

20 楼 superheizai 2010-08-21  

CodingMouse 写道

我认为最好的单例模式是这样写的：

public class CmSdk4jConfigurationReader {
/**
	 * 私有化默认构造器。
	 */
	private CmSdk4jConfigurationReader() { 
		super();
}
/**
	 * 单例模式内部类（内部类式单例模式，利用ClassLoader特性实现延迟加载）。<br><br>
	 * 
	 * 用于创建Cmsdk4j配置档阅读器唯一实例。
	 * @author CodingMouse
	 * @version 1.0
	 * @see CmSdk4jConfigurationReader
	 * @since JDK1.5
	 */
	private static class CmSdk4jConfigurationReaderSingleton {
		
		// 类自身实例
		private static CmSdk4jConfigurationReader instance = new CmSdk4jConfigurationReader();
		
		/**
		 * 静态初始化块，以防止重复读取配置档，减少I/O操作。
		 */
		static {
			instance.loadConfig();
		};
		
	};
	
	/**
	 * 获取当前配置档阅读器实例。<br><br>
	 * 
	 * @return 配置档阅读器实例
	 */
	public static CmSdk4jConfigurationReader getInstance() {
		
		// 当调用了getInstance()，才会创建唯一的实例到内存中，实现了延迟加载
		return CmSdk4jConfigurationReaderSingleton.instance;
		
	}
}

呵呵，那为什么不选用枚举来实现呢？

而且，相信楼主会把这两种例子举出来的：）

19 楼 2010-淡定 2010-08-06  

很透彻，融会贯通了，学习。 自己 学习领悟了 和 真正体验出来了 看来还是有距离的。

18 楼 qn_lf 2010-08-05  

双重检查加锁,既实现线程安全，又能够使性能不受到大的影响

17 楼 CodingMouse 2010-08-05  

我认为最好的单例模式是这样写的：

public class CmSdk4jConfigurationReader {
/**
	 * 私有化默认构造器。
	 */
	private CmSdk4jConfigurationReader() { 
		super();
}
/**
	 * 单例模式内部类（内部类式单例模式，利用ClassLoader特性实现延迟加载）。<br><br>
	 * 
	 * 用于创建Cmsdk4j配置档阅读器唯一实例。
	 * @author CodingMouse
	 * @version 1.0
	 * @see CmSdk4jConfigurationReader
	 * @since JDK1.5
	 */
	private static class CmSdk4jConfigurationReaderSingleton {
		
		// 类自身实例
		private static CmSdk4jConfigurationReader instance = new CmSdk4jConfigurationReader();
		
		/**
		 * 静态初始化块，以防止重复读取配置档，减少I/O操作。
		 */
		static {
			instance.loadConfig();
		};
		
	};
	
	/**
	 * 获取当前配置档阅读器实例。<br><br>
	 * 
	 * @return 配置档阅读器实例
	 */
	public static CmSdk4jConfigurationReader getInstance() {
		
		// 当调用了getInstance()，才会创建唯一的实例到内存中，实现了延迟加载
		return CmSdk4jConfigurationReaderSingleton.instance;
		
	}
}

16 楼 278611293 2010-08-04  

EnterLee 写道

每天在开始工作前都要来看一次您的博客，看看有没有更新，期待楼主的后续模式剖析，期待楼主出书，如果出书了请告诉我一声。谢谢

15 楼 xwangly 2010-08-04  

比较好懂，学习了

14 楼 heqishan 2010-08-04  

看了楼主的单例1，2，3，受益匪浅，期待楼主的下一篇。

effecticve java 有一个原则是，静态方法创建对象优于构造方法，和楼主的单例系列的文章是否有异曲同工之妙呢？呵呵

13 楼 dayday_up1 2010-08-04  

比国内某些所谓的大师写的设计模式书好多了，比国外的大牛写的书似乎更容易让人懂，顶博主。

12 楼 wwf289009 2010-08-04  

楼主分享的精神真的是太好了··文章也太精彩了

11 楼 liliugen 2010-08-04  

几年了，很久没有看到这么好的博文了。居然有人踩，这帮不懂技术的sb

10 楼 kairos 2010-08-03  

写的非常的棒，每一篇都非常的精彩！
更欣赏博主这种share的精神。
牛人很多，可是能与大家share的人并不多。
非常非常的赞，希望楼主继续。

9 楼 viMory 2010-08-03  

期待单例4

8 楼 EnterLee 2010-08-02  

每天在开始工作前都要来看一次您的博客，看看有没有更新，期待楼主的后续模式剖析，期待楼主出书，如果出书了请告诉我一声。谢谢

7 楼 jacky1982728 2010-08-02  

楼主的文章真的挺好，辛苦了，希望坚持下去。。我们会一直支持的。。

6 楼 yangleilt 2010-08-02  

弱弱的问一下：lz工作了多长时间了！我什么时候能像lz那样呢？

5 楼 huxiaoqing 2010-08-02  

ilovehome 写道

看了你所有的文章,写得超级棒,要是出书了,一定买一本,很多内容值得细细咀嚼.

不错，辛苦了

4 楼 qmzpanda 2010-08-02  

博主辛苦了！