1.1.1 摘要
在我们日常的工作中经常需要在应用程序中保持一个唯一的实例，如：io处理，数据库操作等，由于这些对象都要占用重要的系统资源，所以我们必须限制这些实例的创建或始终使用一个公用的实例，这就是我们今天要介绍的——单例模式（singleton）。
使用频率#00f9cfea65101607d0beb0817bc3b09c#高
单件模式（singleton）：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
1.1.2 正文
图1单例模式（singleton）结构图
单例模式（singleton）是几个创建模式中最对立的一个，它的主要特点不是根据用户程序调用生成一个新的实例，而是控制某个类型的实例唯一性，通过上图我们知道它包含的角色只有一个，就是singleton，它拥有一个私有构造函数，这确保用户无法通过new直接实例它。除此之外，该模式中包含一个静态私有成员变量instance与静态公有方法instance()。instance()方法负责检验并实例化自己，然后存储在静态成员变量中，以确保只有一个实例被创建。
图2单例模式（singleton）逻辑模型
接下来我们将介绍6中不同的单例模式（singleton）的实现方式。这些实现方式都有以下的共同点：
1.有一个私有的无参构造函数，这可以防止其他类实例化它，而且单例类也不应该被继承，如果单例类允许继承那么每个子类都可以创建实例，这就违背了singleton模式“唯一实例”的初衷。
2.单例类被定义为sealed,就像前面提到的该类不应该被继承，所以为了保险起见可以把该类定义成不允许派生，但没有要求一定要这样定义。
3.一个静态的变量用来保存单实例的引用。
4.一个公有的静态方法用来获取单实例的引用，如果实例为null即创建一个。
版本一线程不安全
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
/// <summary>/// a simple singleton class implements./// </summary>public sealed class singleton{ private static singleton _instance = null; /// <summary> /// prevents a default instance of the /// <see cref="singleton"/> class from being created. /// </summary> private singleton() { } /// <summary> /// gets the instance. /// </summary> public static singleton instance { get { return _instance ?? (_instance = new singleton()); } }} |
以上的实现方式适用于单线程环境，因为在多线程的环境下有可能得到singleton类的多个实例。假如同时有两个线程去判断
（null == _singleton），并且得到的结果为真，那么两个线程都会创建类singleton的实例，这样就违背了singleton模式“唯一实例”的初衷。
版本二线程安全
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
/// <summary>/// a thread-safe singleton class./// </summary>public sealed class singleton{ private static singleton _instance = null; private static readonly object synobject = new object(); singleton() { } /// <summary> /// gets the instance. /// </summary> public static singleton instance { get { // syn operation. lock (synobject) { return _instance ?? (_instance = new singleton()); } } }} |
以上方式的实现方式是线程安全的，首先我们创建了一个静态只读的进程辅助对象，由于lock是确保当一个线程位于代码的临界区时，另一个线程不能进入临界区（同步操作）。如果其他线程试图进入锁定的代码，则它将一直等待，直到该对象被释放。从而确保在多线程下不会创建多个对象实例了。只是这种实现方式要进行同步操作，这将是影响系统性能的瓶颈和增加了额外的开销。
double-checked locking
前面讲到的线程安全的实现方式的问题是要进行同步操作，那么我们是否可以降低通过操作的次数呢？其实我们只需在同步操作之前，添加判断该实例是否为null就可以降低通过操作的次数了，这样是经典的double-checked locking方法。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
/// <summary>/// double-checked locking implements a thread-safe singleton class/// </summary>public sealed class singleton{ private static singleton _instance = null; // creates an syn object. private static readonly object synobject = new object(); singleton() { } public static singleton instance { get { // double-checked locking if (null == _instance) { lock (synobject) { if (null == _instance) { _instance = new singleton(); } } } return _instance; } }} |
在介绍第四种实现方式之前，首先让我们认识什么是，当字段被标记为beforefieldinit类型时，该字段初始化可以发生在任何时候任何字段被引用之前。这句话听起了有点别扭，接下来让我们通过具体的例子介绍。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
/// <summary>/// defines a test class./// </summary>class test{ public static string x = echoandreturn("in type initializer"); public static string echoandreturn(string s) { console.writeline(s); return s; }} |
上面我们定义了一个包含静态字段和方法的类test，但要注意我们并没有定义静态的构造函数。
图3 test类的il代码
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
class test{ public static string x = echoandreturn("in type initializer"); // defines a parameterless constructor. static test() { } public static string echoandreturn(string s) { console.writeline(s); return s; }} |
上面我们给test类添加一个静态的构造函数。
图4 test类的il代码
通过上面test类的il代码的区别我们发现，当test类包含静态字段，而且没有定义静态的构造函数时，该类会被标记为beforefieldinit。
现在也许有人会问：“被标记为beforefieldinit和没有标记的有什么区别呢”？ok现在让我们通过下面的具体例子看一下它们的区别吧！
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
class test{ public static string x = echoandreturn("in type initializer"); static test() { } public static string echoandreturn(string s) { console.writeline(s); return s; }}class driver{ public static void main() { console.writeline("starting main"); // invoke a static method on test test.echoandreturn("echo!"); console.writeline("after echo"); console.readline(); // the output result: // starting main // in type initializer // echo! // after echo }} |
我相信大家都可以得到答案，如果在调用echoandreturn()方法之前，需要完成静态成员的初始化，所以最终的输出结果如下：
图5输出结果
接着我们在main()方法中添加string y = test.x，如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
public static void main(){ console.writeline("starting main"); // invoke a static method on test test.echoandreturn("echo!"); console.writeline("after echo"); //reference a static field in test string y = test.x; //use the value just to avoid compiler cleverness if (y != null) { console.writeline("after field access"); } console.readkey(); // the output result: // in type initializer // starting main // echo! // after echo // after field access} |
图6 输出结果
通过上面的输出结果，大家可以发现静态字段的初始化跑到了静态方法调用之前，wo难以想象啊！
最后我们在test类中添加一个静态构造函数如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
class test{ public static string x = echoandreturn("in type initializer"); static test() { } public static string echoandreturn(string s) { console.writeline(s); return s; }} |
图7 输出结果
理论上，type initializer应该发生在”echo!”之后和”after echo”之前，但这里却出现了不唯一的结果，只有当test类包含静态构造函数时，才能确保type initializer的初始化发生在”echo!”之后和”after echo”之前。
所以说要确保type initializer发生在被字段引用时，我们应该给该类添加静态构造函数。接下来让我们介绍单例模式的静态方式。
静态初始化
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
public sealed class singleton{ private static readonly singleton _instance = new singleton(); // explicit static constructor to tell c# compiler // not to mark type as beforefieldinit static singleton() { } /// <summary> /// prevents a default instance of the /// <see cref="singleton"/> class from being created. /// </summary> private singleton() { } /// <summary> /// gets the instance. /// </summary> public static singleton instance { get { return _instance; } }} |
以上方式实现比之前介绍的方式都要简单，但它确实是多线程环境下，c#实现的singleton的一种方式。由于这种静态初始化的方式是在自己的字段被引用时才会实例化。
让我们通过il代码来分析静态初始化。
图8静态初始化il代码
首先这里没有beforefieldinit的修饰符，由于我们添加了静态构造函数当静态字段被引用时才进行初始化，因此即便很多线程试图引用_instance，也需要等静态构造函数执行完并把静态成员_instance实例化之后可以使用。
延迟初始化
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
/// <summary>/// delaies initialization./// </summary>public sealed class singleton{ private singleton() { } /// <summary> /// gets the instance. /// </summary> public static singleton instance { get { return nested._instance; } } private class nested { // explicit static constructor to tell c# compiler // not to mark type as beforefieldinit static nested() { } internal static readonly singleton _instance = new singleton(); }} |
这里我们把初始化工作放到nested类中的一个静态成员来完成，这样就实现了延迟初始化。
lazy<t> type
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
/// <summary>/// .net 4's lazy<t> type/// </summary>public sealed class singleton{ private static readonly lazy<singleton> lazy = new lazy<singleton>(() => new singleton()); public static singleton instance { get { return lazy.value; } } private singleton() { }} |
这种方式的简单和性能良好，而且还提供检查是否已经创建实例的属性isvaluecreated。
具体例子
现在让我们使用单例模式（singleton）实现负载平衡器，首先我们定义一个服务器类，它包含服务器名和ip地址如下：
|
1
2
3
4
5
6
7
8
9
10
11
|
/// <summary>/// represents a server machine/// </summary>class server{ // gets or sets server name public string name { get; set; } // gets or sets server ip address public string ip { get; set; }} |
由于负载平衡器只提供一个对象实例供服务器使用，所以我们使用单例模式（singleton）实现该负载平衡器。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
|
/// <summary>/// the 'singleton' class/// </summary>sealed class loadbalancer{ private static readonly loadbalancer _instance = new loadbalancer(); // type-safe generic list of servers private list<server> _servers; private random _random = new random(); static loadbalancer() { } // note: constructor is 'private' private loadbalancer() { // load list of available servers _servers = new list<server> { new server{ name = "serveri", ip = "192.168.0.108" }, new server{ name = "serverii", ip = "192.168.0.109" }, new server{ name = "serveriii", ip = "192.168.0.110" }, new server{ name = "serveriv", ip = "192.168.0.111" }, new server{ name = "serverv", ip = "192.168.0.112" }, }; } /// <summary> /// gets the instance through static initialization. /// </summary> public static loadbalancer instance { get { return _instance; } } // simple, but effective load balancer public server nextserver { get { int r = _random.next(_servers.count); return _servers[r]; } }} |
上面负载平衡器类loadbalancer我们使用静态初始化方式实现单例模式（singleton）。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
static void main(){ loadbalancer b1 = loadbalancer.instance; b1.gethashcode(); loadbalancer b2 = loadbalancer.instance; loadbalancer b3 = loadbalancer.instance; loadbalancer b4 = loadbalancer.instance; // confirm these are the same instance if (b1 == b2 && b2 == b3 && b3 == b4) { console.writeline("same instance\n"); } // next, load balance 15 requests for a server loadbalancer balancer = loadbalancer.instance; for (int i = 0; i < 15; i++) { string servername = balancer.nextserver.name; console.writeline("dispatch request to: " + servername); } console.readkey();} |
图9 loadbalancer输出结果
1.1.3 总结
单例模式的优点：
单例模式（singleton）会控制其实例对象的数量，从而确保访问对象的唯一性。
1.实例控制：单例模式防止其它对象对自己的实例化，确保所有的对象都访问一个实例。
2.伸缩性：因为由类自己来控制实例化进程，类就在改变实例化进程上有相应的伸缩性。
单例模式的缺点：
1.系统开销。虽然这个系统开销看起来很小，但是每次引用这个类实例的时候都要进行实例是否存在的检查。这个问题可以通过静态实例来解决。
2.开发混淆。当使用一个单例模式的对象的时候（特别是定义在类库中的），开发人员必须要记住不能使用new关键字来实例化对象。因为开发者看不到在类库中的源代码，所以当他们发现不能实例化一个类的时候会很惊讶。
3.对象生命周期。单例模式没有提出对象的销毁。在提供内存管理的开发语言（比如，基于.netframework的语言）中，只有单例模式对象自己才能将对象实例销毁，因为只有它拥有对实例的引用。在各种开发语言中，比如c++，其它类可以销毁对象实例，但是这么做将导致单例类内部的指针指向不明。
单例适用性
使用singleton模式有一个必要条件：在一个系统要求一个类只有一个实例时才应当使用单例模式。反之，如果一个类可以有几个实例共存，就不要使用单例模式。
不要使用单例模式存取全局变量。这违背了单例模式的用意，最好放到对应类的静态成员中。
不要将数据库连接做成单例，因为一个系统可能会与数据库有多个连接，并且在有连接池的情况下，应当尽可能及时释放连接。singleton模式由于使用静态成员存储类实例，所以可能会造成资源无法及时释放，带来问题。
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持服务器之家。
原文链接：http://www.cnblogs.com/rush/archive/2011/10/30/2229565.html
