单件模式（Singleton Pattern）（转载）

转自http://terrylee.cnblogs.com/archive/2005/12/09/293509.html


单件模式（Singleton Pattern）

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

Terrylee，2005年12月07日

概述

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

从另一个角度来说，Singleton模式其实也是一种职责型模式。因为我们创建了一个对象，这个对象扮演了独一无二的角色，在这个单独的对象实例中，它集中了它所属类的所有权力，同时它也肩负了行使这种权力的职责！

意图

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

模型图

逻辑模型图：

物理模型图：

生活中的例子

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

五种实现

1．简单实现

 1public 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．安全的线程

 1public 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．双重锁定

 1public 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．静态初始化

 1public 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．延迟初始化

 1public 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类的一个静态成员来完成，这样就实现了延迟初始化，并具有很多的优势，是值得推荐的一种实

现方式。

实现要点

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对象，确保所有的客户程序的请求都只有一个实例来处理。

完整示例

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

 1using System;
 2using System.Threading;
 3
 4namespace 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

 1using System;
 2using System.Threading;
 3using System.Text;
 4
 5namespace 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

 1using System;
 2using System.Text;
 3using System.Threading;
 4
 5namespace 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模式就是“简约而不简单”。

_________________________________________________________________________________________________
源码下载：/Files/Terrylee/SigletonPattern.rar

场景

       我们现在要做一个网络游戏的服务端程序，需要考虑怎么样才能承载大量的用户。在做WEB程序的时候有各种负载均衡的方案，不管是通过硬件实现还是软件实现，基本的思想就是有一个统一的入口，然后由它来分配用户到各个服务器上去。

       需要考虑的问题是，即使在多线程的并发状态下，用户只能通过一个唯一的入口来分配，由此引入了Singleton模式来实现这个唯一的入口。

示例代码

  

using System;

using System.Collections.Generic;

using System.Threading;

namespace SingletonExample

{

    classProgram

    {

        staticvoid Main(string[] args)

        {

            ParameterizedThreadStart ts = newParameterizedThreadStart(EnterPlayer);

            for (int i = 0; i < 20; i++)

            {               

                Thread t = newThread(ts);

                t.Start("player" + i);

            }

            LoadBalanceServer.GetLoadBalanceServer().ShowServerInfo();

     

        }

        staticvoid EnterPlayer(object playerName)

        {

            LoadBalanceServer lbs = LoadBalanceServer.GetLoadBalanceServer();

            lbs.GetLobbyServer().EnterPlayer(playerName.ToString());

        }

    }

    classLoadBalanceServer

    {

        privateconstint SERVER_COUNT = 3;

        privateList<LobbyServer> serverList = newList<LobbyServer>();

        privatestaticvolatileLoadBalanceServer lbs;

        privatestaticobject syncLock = newobject();

        private LoadBalanceServer()

        {

            for (int i = 0; i < SERVER_COUNT; i++)

            {

                serverList.Add(newLobbyServer("LobbyServer" + i));

            }

        }

        publicstaticLoadBalanceServer GetLoadBalanceServer()

        {

            if (lbs == null)

            {

                lock (syncLock)

                {

                    if (lbs == null)

                    {

                        Thread.Sleep(100);

                        lbs = newLoadBalanceServer();

                    }

                }

            }

            return lbs;

        }

        publicLobbyServer GetLobbyServer()

        {

            LobbyServer ls = serverList[0];

            for (int i = 1; i < SERVER_COUNT; i++)

            {

                if (serverList[i].PlayerList.Count < ls.PlayerList.Count)

                    ls = serverList[i];

            }

            return ls;

        }

        publicvoid ShowServerInfo()

        {

            foreach (LobbyServer ls in serverList)

            {

                Console.WriteLine("=================" + ls.ServerName + "=================");

                foreach (string player in ls.PlayerList)

                {

                    Console.WriteLine(player);

                }

            }

        }

   }

    classLobbyServer

    {

        privateList<string> playerList = newList<string>();

        publicList<string> PlayerList

        {

            get { return playerList; }

        }

        privatestring serverName;

        publicstring ServerName

        {

            get { return serverName; }

        }

        public LobbyServer(string serverName)

        {

            this.serverName = serverName;

        }

        publicvoid EnterPlayer(string playerName)

        {

            playerList.Add(playerName);

        }

    }

}

代码执行结果如下图：

 

 

代码说明

l         LoadBalanceServer类实现了Singleton模式，也就是说无论在什么情况下，只会有一个LoadBalanceServer类的实例出现。

l         LobbyServer类表示大厅服务，用户进入大厅后和大厅服务进行服务，在这里我们仅仅在大厅服务里面保存了用户列表。

l         Singleton模式有很多实现方式，在这里使用的是双重锁定方式。对于C#来说，可能使用静态初始化方式是最简洁的，这里就不演示了。

l         LoadBalanceServer类的GetLobbyServer()方法负责返回一个压力最小的LobbyServer对象。

l         实例化LoadBalanceServer的时候Sleep了线程，目的是模拟高并发的情况，在正式代码中没有必要这样做。

何时采用

l         从代码角度来说，当你希望类只有一个实例的时候。

l         从应用角度来说，你希望有一个总管来负责某一件事情。并且这件事情的分配只能有一个人进行，如果有多个人进行肯定会弄乱。比如创建处理流水号如果有两个地方在创建的话是不是就会重复了呢？

实现要点

l         一个Singleton类，它能确保自身的实例是唯一的。

注意事项

l         不要滥用Singleton模式，只有非一个实例不可的情况下才考虑引入Singleton。否则，程序的可扩展性可能会受到限制。