单例（单件）模式的五种实现

Posted on 2013-05-03 21:05  yfldj  阅读(244)  评论(0)    收藏  举报

这是这段时间学习设计模式的时候的源代码。

单例（单件）模式的五种实现。

通过一个计数器的例子调用验证一下。

把下面的代码直接拷进vs下，运行就可以了。（控制台应用程序）

[csharp] 
 
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Text;  
  4.   
  5. using System.Threading;  
  6.   
  7. namespace NetFarmwork  
  8. {  
  9.     class NetFarmwork  
  10.     {  
  11.         static void Main(string[] args)  
  12.         {      
  13.   
  14.             Thread thread0 = Thread.CurrentThread;  
  15.             thread0.Name = "Thread 0";  
  16.             Thread thread1 = new Thread(new ThreadStart(SigletonPattern.SigletonCounter.CountMutilThread.DoSomeWork));  
  17.             thread1.Name = "Thread 1";  
  18.             Thread thread2 = new Thread(new ThreadStart(SigletonPattern.SigletonCounter.CountMutilThread.DoSomeWork));  
  19.             thread2.Name = "Thread 2";  
  20.             Thread thread3 = new Thread(new ThreadStart(SigletonPattern.SigletonCounter.CountMutilThread.DoSomeWork));  
  21.             thread3.Name = "Thread 3";  
  22.   
  23.             thread1.Start();  
  24.             thread2.Start();  
  25.             thread3.Start();  
  26.   
  27.             //线程0也只执行和其他线程相同的工作  
  28.             SigletonPattern.SigletonCounter.CountMutilThread.DoSomeWork();  
  29.   
  30.             Console.ReadKey();  
  31.   
  32.           }  
  33.     }  
[csharp] 
 
  1. #region 单例模式  
  2.  
  3.     #region 用法说明  
  4.   
  5.     //保证一个类仅有一个实例，并提供一个访问它的全局访问点  
  6.   
  7.     //    实现要点   
  8.     //         Singleton模式是限制而不是改进类的创建。   
  9.     //         Singleton类中的实例构造器可以设置为Protected以允许子类派生。   
  10.     //         Singleton模式一般不要支持Icloneable接口，因为这可能导致多个对象实例，与Singleton模式的初衷违背。   
  11.     //         Singleton模式一般不要支持序列化，这也有可能导致多个对象实例，这也与Singleton模式的初衷违背。   
  12.     //         Singleton只考虑了对象创建的管理，没有考虑到销毁的管理，就支持垃圾回收的平台和对象的开销来讲，我们一般没必要对其销毁进行特殊的管理。   
  13.     //         理解和扩展Singleton模式的核心是“如何控制用户使用new对一个类的构造器的任意调用”。   
  14.     //         可以很简单的修改一个Singleton，使它有少数几个实例，这样做是允许的而且是有意义的。   
  15.     //优点   
  16.     //         实例控制：Singleton 会阻止其他对象实例化其自己的 Singleton 对象的副本，从而确保所有对象都访问唯一实例   
  17.     //         灵活性：因为类控制了实例化过程，所以类可以更加灵活修改实例化过程   
  18.     //缺点   
  19.     //         开销：虽然数量很少，但如果每次对象请求引用时都要检查是否存在类的实例，将仍然需要一些开销。可以通过使用静态初始化解决此问题，上面的五种实现方式中已经说过了。   
  20.     //          可能的开发混淆：使用 singleton 对象（尤其在类库中定义的对象）时，开发人员必须记住自己不能使用 new 关键字实例化对象。因为可能无法访问库源代码，因此应用程序开发人员可能会意外发现自己无法直接实例化此类。   
  21.     //         对象的生存期：Singleton 不能解决删除单个对象的问题。在提供内存管理的语言中（例如基于 .NET Framework 的语言），只有 Singleton 类能够导致实例被取消分配，因为它包含对该实例的私有引用。在某些语言中（如 C++），其他类可以删除   
  22.     //对象实例，但这样会导致 Singleton 类中出现悬浮引用。   
  23.     //适用性   
  24.     //         当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时。   
  25.     //         当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时。   
  26.     //应用场景   
  27.     //         每台计算机可以有若干个打印机，但只能有一个Printer Spooler，避免两个打印作业同时输出到打印机。   
  28.     //（摘自吕震宇的C#设计模式（7）－Singleton Pattern）   
  29.     //         PC机中可能有几个串口，但只能有一个COM1口的实例。   
  30.     //         系统中只能有一个窗口管理器。   
  31.     //         .NET Remoting中服务器激活对象中的Sigleton对象，确保所有的客户程序的请求都只有一个实例来处理。  
  32.  
  33. #endregion  

 

[csharp] 
 
    1.  //共有五种实现方案  
    2.       
    3.     /// <summary>  
    4.     /// 简单实现  
    5.     /// 类声明中使用sealed可防止其它类继承此类  
    6.     /// 私有构造函数禁止实例化该类  
    7.     ///   
    8.     /// 缺点：这种方式的实现对于线程来说并不是安全的，因为在多线程的环境下有可能得到Singleton类的多个实例。如果同时有两个线程去判断（instance == null），并且得到的结果为真，这时两个线程都会创建类Singleton的实例，这样就违背了Singleton模式的原则。实际上在上述代码中，有可能在计算出表达式的值之前，对象实例已经被创建，但是内存模型并不能保证对象实例在第二个线程创建之前被发现  
    9.     /// 优点：  
    10.     /// 由于实例是在 Instance 属性方法内部创建的，因此类可以使用附加功能（例如，对子类进行实例化），即使它可能引入不想要的依赖性。            
    11.     /// 直到对象要求产生一个实例才执行实例化；这种方法称为“惰性实例化”。惰性实例化避免了在应用程序启动时实例化不必要的 singleton。  
    12.     /// </summary>  
    13.     public sealed class Singleton  
    14.     {  
    15.         private static Singleton instance = null;  
    16.           
    17.         private Singleton(){}  
    18.   
    19.         public static Singleton Instance  
    20.         {  
    21.             get  
    22.             {  
    23.                 if (instance == null)  
    24.                 {  
    25.                     instance = new Singleton();  
    26.                 }  
    27.                 return instance;  
    28.             }  
    29.         }  
    30.     }  
    31.   
    32.     /// <summary>  
    33.     /// 安全的线程  
    34.     ///   
    35.     /// lock   关键字可以用来确保代码块完成运行，而不会被其他线程中断。这是通过在代码块运行期间为给定对象获取互斥锁来实现的。  
    36.     /// lock   语句以关键字   lock   开头，它有一个作为参数的对象，在该参数的后面还有一个一次只能由一个线程执行的代码块。  
    37.     /// 提供给   lock   关键字的参数必须为基于引用类型的对象，该对象用来定义锁的范围。  
    38.     ///   
    39.     /// 这种方式的实现对于线程来说是安全的。我们首先创建了一个进程辅助对象，线程在进入时先对辅助对象加锁然后再检测对象是否被创建，这样可以确保只有一个实例被创建，因为在同一个时刻加了锁的那部分程序只有一个线程可以进入。这种情况下，对象实例由最先进入的那个线程创建，后来的线程在进入时（instence == null）为假，不会再去创建对象实例了。但是这种实现方式增加了额外的开销，损失了性能。  
    40.     /// </summary>  
    41.     public sealed class Singleton2  
    42.     {  
    43.         private static Singleton2 instance = null;  
    44.         private static readonly object padlock = new object();  
    45.   
    46.         private Singleton2() { }  
    47.   
    48.         public static Singleton2 Instance  
    49.         {  
    50.             get   
    51.             {  
    52.                 lock (padlock)  
    53.                 {  
    54.                     if (instance == null)  
    55.                     {  
    56.                         instance = new Singleton2();  
    57.                     }  
    58.                     return instance;  
    59.                 }  
    60.             }  
    61.         }  
    62.     }  
    63.   
    64.     /// <summary>  
    65.     /// 双重锁定  
    66.     ///   
    67.     /// 这种实现方式对多线程来说是安全的，同时线程不是每次都加锁，只有判断对象实例没有被创建时它才加锁，有了我们上面第一部分的里面的分析，我们知道，加锁后还得再进行对象是否已被创建的判断。它解决了线程并发问题，同时避免在每个 Instance 属性方法的调用中都出现独占锁定。它还允许您将实例化延迟到第一次访问对象时发生。实际上，应用程序很少需要这种类型的实现。大多数情况下我们会用静态初始化。这种方式仍然有很多缺点：无法实现延迟初始化。  
    68.     /// </summary>  
    69.     public sealed class Singleton3  
    70.     {  
    71.         private static Singleton3 instance = null;  
    72.         private static readonly object padlock = new object();  
    73.   
    74.         private Singleton3() { }  
    75.   
    76.         public static Singleton3 Instance  
    77.         {  
    78.             get   
    79.             {  
    80.                 if (instance == null)  
    81.                 {  
    82.                     lock (padlock)  
    83.                     {  
    84.                         if (instance == null)  
    85.                         {  
    86.                             instance = new Singleton3();  
    87.                         }  
    88.                     }  
    89.                 }  
    90.                 return instance;  
    91.             }  
    92.         }  
    93.     }  
    94.   
    95.     /// <summary>  
    96.     /// 静态初始化  
    97.     /// 在大多数情况下，静态初始化是在 .NET 中实现 Singleton 的首选方法。  
    98.     /// 该类标记为 sealed 以阻止发生派生，而派生可能会增加实例。此外，变量标记为 readonly，这意味着只能在静态初始化期间（此处显示的示例）或在类构造函数中分配变量。   
    99.     ///   
    100.     /// 该实现与前面的示例类似，不同之处在于它依赖公共语言运行库来初始化变量。它仍然可以用来解决 Singleton 模式试图解决的两个基本问题：全局访问和实例化控制。公共静态属性为访问实例提供了一个全局访问点。此外，由于构造函数是私有的，因此不能在类本身以外实例化 Singleton 类；因此，变量引用的是可以在系统中存在的唯一的实例。 由于 Singleton 实例被私有静态成员变量引用，因此在类首次被对 Instance 属性的调用所引用之前，不会发生实例化。  
    101.     /// 这种方法唯一的潜在缺点是，您对实例化机制的控制权较少。在 Design Patterns 形式中，您能够在实例化之前使用非默认的构造函数或执行其他任务。由于在此解决方案中由 .NET Framework 负责执行初始化，因此您没有这些选项。在大多数情况下，静态初始化是在 .NET 中实现 Singleton 的首选方法。  
    102.     /// </summary>  
    103.     public sealed class Singleton4  
    104.     {   
    105.         private static readonly Singleton4 instance = new Singleton4();  
    106.   
    107.         static Singleton4() { }  
    108.   
    109.         private Singleton4() { }  
    110.   
    111.         public static Singleton4 Instance  
    112.         {  
    113.             get  
    114.             {  
    115.                 return instance;  
    116.             }  
    117.         }  
    118.     }  
    119.   
    120.     /// <summary>  
    121.     /// 延迟初始化  
    122.     /// 类声明了internal后只对整个项目可见，虽然其成员可以是public声明的，但因类只在当前项目中可见，所以其成员也就只能在当前项目访问了。  
    123.     ///   
    124.     /// 这里，初始化工作有Nested类的一个静态成员来完成，这样就实现了延迟初始化，并具有很多的优势，是值得推荐的一种实现方式  
    125.     /// </summary>  
    126.     public sealed class Singleton5  
    127.     {  
    128.         private Singleton5() { }  
    129.   
    130.         public static Singleton5 Instance  
    131.         {  
    132.             get  
    133.             {  
    134.                 return Nested.instance;  
    135.             }  
    136.         }  
    137.   
    138.         private class Nested  
    139.         {  
    140.             static Nested() { }  
    141.   
    142.             internal static readonly Singleton5 instance = new Singleton5();  
    143.         }  
    144.     }  
    145.  
    146.     #endregion  
    147.   
    148. }  
    149.  
    150. #region 单例模式测试示例  
    151.   
    152. namespace SigletonPattern.SigletonCounter  
    153. {   
    154.     using System;   
    155.     using System.Threading;  
    156.   
    157.     /// <summary>  
    158.     /// 功能：简单计数器的单件模式  
    159.     /// 日期：2009年8月19日   
    160.     /// </summary>  
    161.     public class CountSigleton  
    162.     {  
    163.         //存储唯一的实例  
    164.         private static CountSigleton uniCounter = new CountSigleton();  
    165.   
    166.         //存储计数值  
    167.         private int totalNum = 0;  
    168.   
    169.         private CountSigleton()  
    170.         {  
    171.             //线程延迟2000毫秒  
    172.             Thread.Sleep(2000);  
    173.         }  
    174.   
    175.         public static CountSigleton Instance()  
    176.         {  
    177.             return uniCounter;  
    178.         }  
    179.   
    180.         //计数加1   
    181.         public void Add()  
    182.         {  
    183.             totalNum++;  
    184.         }  
    185.   
    186.         //获得当前计数值  
    187.         public int GetCounter()  
    188.         {  
    189.             return totalNum;  
    190.         }  
    191.     }  
    192. }  
    193.   
    194. namespace SigletonPattern.SigletonCounter   
    195. {  
    196.     using System;  
    197.     using System.Threading;  
    198.     using System.Text;  
    199.   
    200.     /// <summary>  
    201.     /// 功能：创建一个多线程计数的类  
    202.     /// 日期：2009年8月19日  
    203.     /// </summary>  
    204.     public class CountMutilThread  
    205.     {  
    206.         public CountMutilThread()  
    207.         { }  
    208.   
    209.         public static void DoSomeWork()  
    210.         {  
    211.             //构造显示字符串  
    212.             string results = "";  
    213.   
    214.             //创建一个Sigleton实例  
    215.             CountSigleton MyCounter = CountSigleton.Instance();  
    216.   
    217.             //循环调用四次(四个线程循环执行四次，即MyCounter.Add()了十六次，最终的结果是计数器最大为16)  
    218.             for (int i = 1; i < 5; i++)  
    219.             {  
    220.                 MyCounter.Add();  
    221.   
    222.                 results += "线程";  
    223.                 results += Thread.CurrentThread.Name.ToString() + "——>";  
    224.                 results += "当前的计数：";  
    225.                 results += MyCounter.GetCounter().ToString();  
    226.                 results += "\n";  
    227.   
    228.                 Console.WriteLine(results);  
    229.                 //清空显示字符串  
    230.                 results = "";  
    231.             }  
    232.         }  
    233.     }  
    234. }  
    235.  
    236. #endregion  

 

博客园  ©  2004-2025
浙公网安备 33010602011771号 浙ICP备2021040463号-3