CSharp面向对象设计模式纵横谈--Singleton Pattern 听课笔记

 

模式分类：

       从目的看：

              创建型（Creational）模式：负责对象创建

              结构型（Structural）模式：处理类与对象间的组合

              行为型（Behavioral）模式：类与对象交互中的职责分配

从范围看：

       类模式处理类与子类的静态关系

       对象模式处理对象间的动态关系

 

动机（Motivation）

       在软件系统中，经常有这样一些特殊的类，必须保证它们在系统中只存在一个实例，才能确保它们的逻辑正确性，以及良好的效率。

       如果绕过常规的构造器，提供一种机制类保证一个类只有一个实例？

       这应该是类设计者的责任，而不是使用者的责任。

 

意图（Intent）

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

 

单线程Singleton模式实现

 1Public class Singleton
 2       {
 3              Private static Singleton instance;
 4              Private Singleton(){}
 5
 6              Public static Singleton Instance
 7              {
 8                     Get
 9                     {
10                            If(instance==null)
11                            {
12                                   Instance=new Singleton();
13
14                            }
15
16                            Return instance;
17
18                     }
19              }
20       }
21
22class Test
23{
24public static void Main()
25
26{
27
28Singleton t1=Singleton.Instance;
29
30Singleton t2=Singleton.Instance;
31
32}
33
34}
35
36

 

Exceptions 和 Singleton：

       以上的方式需要每次都来检查Instance是否为空，我们可以创建自己的Exception类来捕捉Instance不为空时的操作。

      

 1 public class SingletionException:Exception
 2
 3       {
 4
 5              Public SingletonException(string s):base(s)
 6
 7              {
 8
 9              }
10
11       }
12
13

在Instance不为NULL时抛出异常：

public class Singleton

{

       private static bool flag_Instance=false;

       private Singleton()

       {

       }

 

       public static GetSingleton()

       {

              if(flag_Instance)

              {

                     throw new SingletonException("Only one Instance allowed");

              }

              else

              {

                     flag_Instance=true;

              }

       }

};

 

单线程Singleton模式的几个要点：

1．  Singleton模式中的实例构造器可以设置为Protected以允许子类派生。

2．  Singleton模式一般不要支持IConeable接口，因为这可能会导致多个对象实例，与Singleton模式的初衷违背。

3．  Singleton模式一般不要支持序列化，因为这也有可能导致多个对象实例，同样与Singleton模式的初衷违背。

4．  Singleton模式只考虑到了对象创建的管理，没有考虑对象销毁的管理。就支持垃圾挥手的平台和对象的开销来讲，我们一般没有必要对其进行特殊的管理。

5．  不能应对多线程环境，在多线程环境下，使用Singleton模式仍然有可能得到Singleton类的多个实例对象。

 

多线程Singletion模式：

1.使用double-check来完成

 1class Singleton
 2
 3{
 4
 5       private static volatile Singleton instance=null;//volatile在编译是不进行微调
 6
 7       private static object lockHelper=new Object();
 8
 9 
10
11       private Singleton()//私有构造器，使得Singleton 只可以在本类的内部被创建
12
13       {
14
15       }
16
17 
18
19       public static Singleton Instance
20
21       {
22
23              get
24
25              {
26
27                     if(instance==null)
28
29                     {
30
31                            lock(lockHelper)
32
33                            {
34
35                                   if(instance==null)//避免了两个线程产生两个实例的危险
36
37                                   {
38
39                                          instance=new Singleton();
40
41                                   }
42
43                            }
44
45                     }
46
47 
48
49                     return instance;
50
51              }
52
53       }
54
55};
56
57

2.多线程Singleton Pattern的一种更好的方式：

 1class Singleton
 2
 3{
 4
 5       public static readonly Singleton Instance=new Singleton();
 6
 7       private Singleton()
 8
 9       {
10
11       }
12
13};
14
15

 

3.上述代码等同于：

 1class Singleton
 2
 3{
 4
 5       public static readonly Singleton Instance;
 6
 7 
 8
 9       static Singleton()
10
11       {
12
13              Instance =new Singleton();
14
15       }
16
17 
18
19       private Singleton()
20
21       {
22
23       }
24
25};
26
27

 

 

Singleton模式扩展：

1．  将一个实例扩展到N个实例，例如对象池的实现。（N是固定的）。

2．  将new构造器的调用转移到其他类中，例如多个类协同工作环境中，某个局部环境只需要拥有某个类的一个实例。

3．  理解和扩展SINGLETON模式的核心是“如何控制用户使用new对一个类的实例构造器的任意调用“。

转载于:https://www.cnblogs.com/leib_0474/archive/2005/10/25/261954.html