设计模式——单例模式（Singleton）

要想正确理解设计模式，首先必须明确它是为了解决什么问题而提出来的。

设计模式学习笔记

——Shulin

转载请注明出处：http://blog.csdn.net/zhshulin

       

       单例模式属于设计模式中的创建模式，即创建对象时，不再由我们直接实例化对象，而是根据特定场景，由程序来确定创建对象的方式，从而保证更大的性能、更好的架构优势。

1、概念

        单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。选择单例模式就是为了避免不一致状态。使用Singleton的好处还在于可以节省内存，因为它限制了实例的个数，有利于Java垃圾回收（garbage collection）。

       Singleton模式看起来简单，使用方法也很方便，但是真正用好，是非常不容易，需要对Java的类 线程 内存等概念有相当的了解。

       总之：如果你的应用基于容器，那么Singleton模式少用或者不用，可以使用相关替代技术。

2、特点

   1）单例类只能有一个实例

     2）单例类必须自己创建自己的唯一实例

     3）单例类必须给所有其他对象提供这一实例

3、应用举例

    在很多操作中，比如建立目录、数据库连接都需要这样的单线程操作。还有, singleton能够被状态化; 这样，多个单态类在一起就可以作为一个状态仓库一样向外提供服务，比如，你要论坛中的帖子计数器，每次浏览一次需要计数，单态类能否保持住这个计数，并且能synchronize的安全自动加1，如果你要把这个数字永久保存到数据库，你可以在不修改单态接口的情况下方便的做到。

 

    在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机，但只能有一个Printer Spooler，以避免两个打印作业同时输出到打印机中。每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以避免一个通信端口同时被两个请求同时调用。

我将列出一些就在咱们周边和很有意义的单例应用场景。

1. Windows的Task Manager（任务管理器）就是很典型的单例模式（这个很熟悉吧），想想看，是不是呢，你能打开两个windows task manager吗？ 不信你自己试试看哦~ 

2. windows的Recycle Bin（回收站）也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。

3. 网站的计数器，一般也是采用单例模式实现，否则难以同步。

4. 应用程序的日志应用，一般都何用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。

5. Web应用的配置对象的读取，一般也应用单例模式，这个是由于配置文件是共享的资源。

6. 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。数据库软件系统中使用数据库连接池，主要是节省打开或者关闭数据库连接所引起的效率损耗，这种效率上的损耗还是非常昂贵的，因为何用单例模式来维护，就可以大大降低这种损耗。

7. 多线程的线程池的设计一般也是采用单例模式，这是由于线程池要方便对池中的线程进行控制。

8. 操作系统的文件系统，也是大的单例模式实现的具体例子，一个操作系统只能有一个文件系统。

9. HttpApplication 也是单位例的典型应用。熟悉ASP.Net(IIS)的整个请求生命周期的人应该知道HttpApplication也是单例模式，所有的HttpModule都共享一个HttpApplication实例.

 

总结以上，不难看出：

　　单例模式应用的场景一般发现在以下条件下：

　　（1）资源共享的情况下，避免由于资源操作时导致的性能或损耗等。如上述中的日志文件，应用配置。

　　（2）控制资源的情况下，方便资源之间的互相通信。如线程池等。

4、实现

    几种常见单例模式实现方法。通用的单例模式创建思想：

1）使用private修改该类构造器，从而将其隐藏起来，避免程序自由创建该类实例

        2）提供一个public方法获取该类实例，且此方法必须使用static修饰（调用之前还不存在对象，因此只能用类调用）

        3）该类必须缓存已经创建的对象，否则该类无法知道是否曾经创建过实例，也就无法保证只创建一个实例。为此，该类需要一个静态属性来保持曾经创建的实例。

4.1、饿汉模式

基本结构：

[java]  view plain  copy

 print ?

1. public class EagerSingleton {  
2.     private static EagerSingleton instance = new EagerSingleton();  
3.     /** 
4.      * 私有默认构造方法 
5.      */  
6.     private EagerSingleton(){}  
7.     /** 
8.      * 静态工厂方法 
9.      */  
10.     public static EagerSingleton getInstance(){  
11.         return instance;  
12.     }  
13. }  

   饿汉式是一种比较形象的称谓。既然饿，那么在创建对象实例的时候就比较着急，于是在装载类的时候就创建对象实例。饿汉式是典型的空间换时间，当类装载的时候就会创建类的实例，不管你用不用，先创建出来，然后每次调用的时候，就不需要再判断，节省了运行时间。

4.2、懒汉模式

基本结构：

[java]  view plain  copy

 print ?

1. package org.zsl.designmode;  
2. /** 
3.  * 懒汉式，需要的时候才创建，典型的时间换空间 
4.  * @author ZSL 
5.  * 
6.  */  
7. public class LazySingleton {  
8.     //静态属性用来缓存创建实例  
9.     private static LazySingleton instance = null;  
10.     //私有构造方法避免程序自由创建实例  
11.     private LazySingleton(){}  
12.     //静态公共方法用于取得该类实例  
13.     public static synchronized LazySingleton getLazySingletonInstance(){  
14.         if(instance == null){  
15.             instance = new LazySingleton();  
16.         }  
17.         return instance;  
18.     }  
19. }  

    上面的懒汉式单例类实现里对静态工厂方法使用了同步化，以处理多线程环境。

    懒汉式其实是一种比较形象的称谓。既然懒，那么在创建对象实例的时候就不着急。会一直等到马上要使用对象实例的时候才会创建，懒人嘛，总是推脱不开的时候才会真正去执行工作，因此在装载对象的时候不创建对象实例。

 

　　懒汉式是典型的时间换空间,就是每次获取实例都会进行判断，看是否需要创建实例，浪费判断的时间。当然，如果一直没有人使用的话，那就不会创建实例，则节约内存空间

 

　　由于懒汉式的实现是线程安全的，这样会降低整个访问的速度，而且每次都要判断。那么有没有更好的方式实现呢？

4.3、双重检查加锁

    可以使用“双重检查加锁”的方式来实现，就可以既实现线程安全，又能够使性能不受很大的影响。

 

　　“双重检查加锁”指的是：并不是每次进入getInstance方法都需要同步，而是先不同步，进入方法后，先检查实例是否存在，如果不存在才进行下面的同步块，这是第一重检查，进入同步块过后，再次检查实例是否存在，如果不存在，就在同步的情况下创建一个实例，这是第二重检查。这样一来，就只需要同步一次了，从而减少了多次在同步情况下进行判断所浪费的时间。

 

　　“双重检查加锁”机制的实现会使用关键字volatile，它的意思是：被volatile修饰的变量的值，将不会被本地线程缓存，所有对该变量的读写都是直接操作共享内存，从而确保多个线程能正确的处理该变量。

 

注意：在java1.4及以前版本中，很多JVM对于volatile关键字的实现的问题，会导致“双重检查加锁”的失败，因此“双重检查加锁”机制只只能用在java5及以上的版本。

[java]  view plain  copy

 print ?

1. package org.zsl.designmode;  
2. /** 
3.  * 双重检查加锁，既实现线程安全，又能够使性能不受很大的影响 
4.  * @author ZSL 
5.  * 
6.  */  
7. public class Singleton {  
8.     //被volatile修饰的变量的值，将不会被本地线程缓存，所有对该变量的读写都是直接操作共享内存，从而确保多个线程能正确的处理该变量。  
9.     private volatile static Singleton instance = null;  
10.     //私有构造方法  
11.     private Singleton(){};  
12.     //公共静态方法获取实例  
13.     public static Singleton getSingletonInstance(){  
14.         if(instance == null){   //先检查实例是否存在，不存在，在进行同步  
15.             synchronized (Singleton.class) {    //同步块，线程安全的创建实例  
16.                 if(instance == null){   //再次检查实例是否存在，如果不存在才真正的创建实例  
17.                     instance = new Singleton();  
18.                 }  
19.             }  
20.               
21.         }  
22.         return instance;  
23.     }  
24.       
25. }  

这种实现方式既可以实现线程安全地创建实例，而又不会对性能造成太大的影响。它只是第一次创建实例的时候同步，以后就不需要同步了，从而加快了运行速度。

 

　　提示：由于volatile关键字可能会屏蔽掉虚拟机中一些必要的代码优化，所以运行效率并不是很高。因此一般建议，没有特别的需要，不要使用。也就是说，虽然可以使用“双重检查加锁”机制来实现线程安全的单例，但并不建议大量采用，可以根据情况来选用。

（原文地址：http://blog.csdn.net/zhshulin）