NET设计模式（2）：单件模式（Singleton Pattern）[转载]

单件模式（Singleton Pattern）

——.NET设计模式系列之二

Terrylee，2005年12月07日

概述

Singleton模式要求一个类有且仅有一个实例，而且提供了一个全局的访问点。这就提出了一个问题：如何绕过常规的构造器，提供一种机制来保证一个类只有一个实例？客户程序在调用某一个类时，它是不会考虑这个类是否只能有一个实例等问题的，因此，这应该是类设计者的责任，而不是类使用者的责任。

从另外一个角度来讲，Singleton模式其实也是一种职责型模式。由于咱们建立了一个对象，这个对象扮演了独一无二的角色，在这个单独的对象实例中，它集中了它所属类的全部权力，同时它也肩负了行使这种权力的职责！

意图

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

模型图

逻辑模型图：

物理模型图：

生活中的例子

美国总统的职位是Singleton，美国宪法规定了总统的选举，任期以及继任的顺序。这样，在任什么时候刻只能由一个现任的总统。不管现任总统的身份为什么，其头衔"美利坚合众国总统"是访问这个职位的人的一个全局的访问点。

五种实现

1．简单实现

 

 

 1 public   sealed   class  Singleton
 2 {
 3    static Singleton instance=null;
 4
 5    Singleton()
 6    {
 7    }
 8
 9    public static Singleton Instance
10    {
11        get
12        {
13            if (instance==null)
14            {
15                instance = new Singleton();
16            }
17            return instance;
18        }
19    }
20}

这种方式的实现对于线程来讲并非安全的，由于在多线程的环境下有可能获得Singleton类的多个实例。若是同时有两个线程去判断（instance == null），而且获得的结果为真，这时两个线程都会建立类Singleton的实例，这样就违背了Singleton模式的原则。实际上在上述代码中，有可能在计算出表达式的值以前，对象实例已经被建立，可是内存模型并不能保证对象实例在第二个线程建立以前被发现。

 

该实现方式主要有两个优势：

l         因为实例是在 Instance属性方法内部建立的，所以类可使用附加功能（例如，对子类进行实例化），即便它可能引入不想要的依赖性。

l         直到对象要求产生一个实例才执行实例化；这种方法称为“惰性实例化”。惰性实例化避免了在应用程序启动时实例化没必要要的 singleton。

2．安全的线程

 1 public   sealed   class  Singleton
 2 {
 3    static Singleton instance=null;
 4    static readonly object padlock = new object();
 5
 6    Singleton()
 7    {
 8    }
 9
10    public static Singleton Instance
11    {
12        get
13        {
14            lock (padlock)
15            {
16                if (instance==null)
17                {
18                    instance = new Singleton();
19                }
20                return instance;
21            }
22        }
23    }
24}
25
26

 

这种方式的实现对于线程来讲是安全的。咱们首先建立了一个进程辅助对象，线程在进入时先对辅助对象加锁而后再检测对象是否被建立，这样能够确保只有一个实例被建立，由于在同一个时刻加了锁的那部分程序只有一个线程能够进入。这种状况下，对象实例由最早进入的那个线程建立，后来的线程在进入时（instence == null）为假，不会再去建立对象实例了。可是这种实现方式增长了额外的开销，损失了性能。

3．双重锁定

 1 public   sealed   class  Singleton
 2 {
 3    static Singleton instance=null;
 4    static readonly object padlock = new object();
 5
 6    Singleton()
 7    {
 8    }
 9
10    public static Singleton Instance
11    {
12        get
13        {
14            if (instance==null)
15            {
16                lock (padlock)
17                {
18                    if (instance==null)
19                    {
20                        instance = new Singleton();
21                    }
22                }
23            }
24            return instance;
25        }
26    }
27}
28

这种实现方式对多线程来讲是安全的，同时线程不是每次都加锁，只有判断对象实例没有被建立时它才加锁，有了咱们上面第一部分的里面的分析，咱们知道，加锁后还得再进行对象是否已被建立的判断。它解决了线程并发问题，同时避免在每一个 Instance属性方法的调用中都出现独占锁定。它还容许您将实例化延迟到第一次访问对象时发生。实际上，应用程序不多须要这种类型的实现。大多数状况下咱们会用静态初始化。这种方式仍然有不少缺点：没法实现延迟初始化。

4．静态初始化

 1 public   sealed   class  Singleton
 2 {
 3    static readonly Singleton instance=new Singleton();
 4
 5    static Singleton()
 6    {
 7    }
 8
 9    Singleton()
10    {
11    }
12
13    public static Singleton Instance
14    {
15        get
16        {
17            return instance;
18        }
19    }
20}
21

看到上面这段富有戏剧性的代码，咱们可能会产生怀疑，这仍是Singleton模式吗？在此实现中，将在第一次引用类的任何成员时建立实例。公共语言运行库负责处理变量初始化。该类标记为 sealed 以阻止发生派生，而派生可能会增长实例。此外，变量标记为 readonly，这意味着只能在静态初始化期间（此处显示的示例）或在类构造函数中分配变量。

该实现与前面的示例相似，不一样之处在于它依赖公共语言运行库来初始化变量。它仍然能够用来解决 Singleton模式试图解决的两个基本问题：全局访问和实例化控制。公共静态属性为访问实例提供了一个全局访问点。此外，因为构造函数是私有的，所以不能在类自己之外实例化 Singleton 类；所以，变量引用的是能够在系统中存在的惟一的实例。

因为 Singleton 实例被私有静态成员变量引用，所以在类首次被对 Instance属性的调用所引用以前，不会发生实例化。

这种方法惟一的潜在缺点是，您对实例化机制的控制权较少。在 Design Patterns形式中，您可以在实例化以前使用非默认的构造函数或执行其余任务。因为在此解决方案中由 .NET Framework 负责执行初始化，所以您没有这些选项。在大多数状况下，静态初始化是在 .NET 中实现 Singleton的首选方法。

5．延迟初始化

 1 public   sealed   class  Singleton
 2 {
 3    Singleton()
 4    {
 5    }
 6
 7    public static Singleton Instance
 8    {
 9        get
10        {
11            return Nested.instance;
12        }
13    }
14    
15    class Nested
16    {
17        static Nested()
18        {
19        }
20
21        internal static readonly Singleton instance = new Singleton();
22    }
23}
24

这里，初始化工做有Nested类的一个静态成员来完成，这样就实现了延迟初始化，并具备不少的优点，是值得推荐的一种实

现方式。

 

---

 

本 人 添 加

通常项目中都这样作

public class Student
{
    public static readonly Student Instance = new Student();

    private Student()
    {
    }

    //...
}

View Code

这个是线程安全的, 而且也是最简单的写法.

 

---

 

实现要点

l        Singleton模式是限制而不是改进类的建立。

l         Singleton类中的实例构造器能够设置为Protected以容许子类派生。

l         Singleton模式通常不要支持Icloneable接口，由于这可能致使多个对象实例，与Singleton模式的初衷违背。

l         Singleton模式通常不要支持序列化，这也有可能致使多个对象实例，这也与Singleton模式的初衷违背。

l         Singleton只考虑了对象建立的管理，没有考虑到销毁的管理，就支持垃圾回收的平台和对象的开销来说，咱们通常不必对其销毁进行特殊的管理。

l         理解和扩展Singleton模式的核心是“如何控制用户使用new对一个类的构造器的任意调用”。

 

 

l         能够很简单的修改一个Singleton，使它有少数几个实例，这样作是容许的并且是有意义的。

优势

l         实例控制：Singleton会阻止其余对象实例化其本身的 Singleton对象的副本，从而确保全部对象都访问惟一实例

l         灵活性：由于类控制了实例化过程，因此类能够更加灵活修改实例化过程

缺点

l         开销：虽然数量不多，但若是每次对象请求引用时都要检查是否存在类的实例，将仍然须要一些开销。能够经过使用静态初始化解决此问题，上面的五种实现方式中已经说过了。

l          可能的开发混淆：使用 singleton对象（尤为在类库中定义的对象）时，开发人员必须记住本身不能使用 new 关键字实例化对象。由于可能没法访问库源代码，所以应用程序开发人员可能会意外发现本身没法直接实例化此类。

l         对象的生存期：Singleton 不能解决删除单个对象的问题。在提供内存管理的语言中（例如基于 .NET Framework 的语言），只有 Singleton类可以致使实例被取消分配，由于它包含对该实例的私有引用。在某些语言中（如 C++），其余类能够删除
对象实例，但这样会致使 Singleton类中出现悬浮引用。

适用性

l         当类只能有一个实例并且客户能够从一个众所周知的访问点访问它时。

l         当这个惟一实例应该是经过子类化可扩展的，而且客户应该无需更改代码就能使用一个扩展的实例时。

应用场景

l         每台计算机能够有若干个打印机，但只能有一个Printer Spooler，避免两个打印做业同时输出到打印机。
（摘自吕震宇的C#设计模式（7）－Singleton Pattern）

l         PC机中可能有几个串口，但只能有一个COM1口的实例。

l         系统中只能有一个窗口管理器。

l         .NET Remoting中服务器激活对象中的Sigleton对象，确保全部的客户程序的请求都只有一个实例来处理。

完整示例

这是一个简单的计数器例子，四个线程同时进行计数。

 

 1 using  System;
 2 using  System.Threading;
 3
 4 namespace  SigletonPattern.SigletonCounter
 5 {
 6    /**//// <summary>
 7    /// 功能：简单计数器的单件模式
 8    /// 编写：Terrylee
 9    /// 日期：2005年12月06日
10    /// </summary>
11    public class CountSigleton
12    {
13        /**////存储惟一的实例
14        static CountSigleton uniCounter = new CountSigleton();  
15   
16        /**////存储计数值
17        private int totNum = 0;  
18   
19        private CountSigleton() 
20   
21        { 
22            /**////线程延迟2000毫秒
23            Thread.Sleep(2000);
24        } 
25   
26        static public CountSigleton Instance() 
27   
28        { 
29   
30            return uniCounter; 
31   
32        } 
33        
34        /**////计数加1
35        public void Add()
36        { 
37            totNum ++;
38        }  
39        
40        /**////得到当前计数值
41        public int GetCounter()
42        { 
43            return totNum;
44        } 
45
46    }
47}
48

 

 1 using  System;
 2 using  System.Threading;
 3 using  System.Text;
 4
 5 namespace  SigletonPattern.SigletonCounter
 6 {
 7    /**//// <summary>
 8    /// 功能：建立一个多线程计数的类
 9    /// 编写：Terrylee
10    /// 日期：2005年12月06日
11    /// </summary>
12    public class CountMutilThread
13    {
14        public CountMutilThread()
15        {
16            
17        }
18
19        /**//// <summary>
20        /// 线程工做
21        /// </summary>
22        public static void DoSomeWork()
23        {
24            /**////构造显示字符串
25            string results = "";
26
27            /**////建立一个Sigleton实例
28            CountSigleton MyCounter = CountSigleton.Instance();
29
30            /**////循环调用四次
31            for(int i=1;i<5;i++)
32            {
33                /**////开始计数
34                MyCounter.Add();
35                
36                results +="线程";
37                results += Thread.CurrentThread.Name.ToString() + "——〉";
38                results += "当前的计数：";
39                results += MyCounter.GetCounter().ToString();
40                results += "\n";
41
42                Console.WriteLine(results);
43                
44                /**////清空显示字符串
45                results = "";
46            }
47        }
48
49        public void StartMain()
50        {
51
52            Thread thread0 = Thread.CurrentThread; 
53   
54            thread0.Name = "Thread 0"; 
55   
56            Thread thread1 =new Thread(new ThreadStart(DoSomeWork)); 
57   
58            thread1.Name = "Thread 1"; 
59   
60            Thread thread2 =new Thread(new ThreadStart(DoSomeWork)); 
61   
62            thread2.Name = "Thread 2"; 
63   
64            Thread thread3 =new Thread(new ThreadStart(DoSomeWork)); 
65   
66            thread3.Name = "Thread 3"; 
67   
68            thread1.Start(); 
69   
70            thread2.Start(); 
71   
72            thread3.Start(); 
73            
74            /**////线程0也只执行和其余线程相同的工做
75            DoSomeWork(); 
76        }
77    }
78}
79

 

 1 using  System;
 2 using  System.Text;
 3 using  System.Threading;
 4
 5 namespace  SigletonPattern.SigletonCounter
 6 {
 7    /**//// <summary>
 8    /// 功能：实现多线程计数器的客户端
 9    /// 编写：Terrylee
10    /// 日期：2005年12月06日
11    /// </summary>
12    public class CountClient
13    {
14        public static void Main(string[] args)
15        {
16       CountMutilThread cmt = new CountMutilThread();
17
18            cmt.StartMain();
19
20            Console.ReadLine();
21        }
22    }
23}
24

 

总结

Singleton设计模式是一个很是有用的机制，可用于在面向对象的应用程序中提供单个访问点。文中经过五种实现方式的比较和一个完整的示例，完成了对Singleton模式的一个总结和探索。用一句广告词来归纳Singleton模式就是“简约而不简单”。

原地址:http://terrylee.cnblogs.com/archive/2005/12/09/293509.html