设计模式之一：单例模式（Singleton Pattern）
写这个系列的文章，只为把所学的设计模式再系统的整理一遍。错误和不周到的地方欢迎大家批评。点击这里下载源代码。
什么时候使用单例模式
在程序运行时，某种类型只需要一个实例时，一般采用单例模式。为什么需要一个实例？第一，性能，第二，保持代码简洁，比如程序中通过某个配置类A读取配置文件，如果在每处使用的地方都new A()，才能读取配置项，一个是浪费系统资源（参考.NET垃圾回收机制），再者重复代码太多。
单例模式的实现
实现单例模式，方法非常多，这里我把见过的方式都过一遍，来体会如何在支持并发访问、性能、代码简洁程度等方面不断追求极致。（单击此处下载代码）
实现1：非线程安全
1: using System;
2: using System.Collections.Generic;
3: using System.Linq;
4: using System.Text;
5: using System.Threading;
6: using System.Threading.Tasks;
7:
8: namespace SingletonPatternNotTheadSafe
9: {
10: public sealed class Singleton
11: {
12: private static Singleton instance = null;
13:
14: private Singleton()
15: {
16: }
17:
18: public static Singleton Instance
19: {
20: get
21: {
22: if (instance == null)
23: {
24: Thread.Sleep(1000);
25: instance = new Singleton();
26: Console.WriteLine(string.Format(
27: "[{0}]创建Singleton {1}" , Thread.CurrentThread.ManagedThreadId, instance.GetHashCode()));
28: }
29:
30: Console.WriteLine(string.Format(
31: "[{0}]获得Singleton {1}", Thread.CurrentThread.ManagedThreadId, instance.GetHashCode()));
32: return instance;
33: }
34: }
35: }
36: }
为了能够在下面的测试代码中展示上面代码的问题，这里在创建对象前，让线程休息1秒，并且在控制台打印出当前线程ID、对象的hashcode（一般不同对象的hashcode是不一样的，但可能重复）。
1: using System;
2: using System.Collections.Generic;
3: using System.Linq;
4: using System.Text;
5: using System.Threading;
6: using System.Threading.Tasks;
7:
8: namespace SingletonPatternNotTheadSafe
9: {
10: class Program
11: {
12: private static void Main(string[] args)
13: {
14: Thread t1 = new Thread(new ThreadStart(Compute));
15:
16: t1.Start();
17:
18: Compute();
19:
20: Console.ReadLine(); // 阻止主线程结束
21: }
22:
23: private static void Compute()
24: {
25: Singleton o1 = Singleton.Instance;
26: }
27: }
28: }
执行结果如下：
分析：
Singleton.Instance的get方法中创建instance并未考虑并发访问的情况，导致可能重复创建Singleton对象。下面的实现方法修复了此问题。
实现2：简单线程安全
要解决上面的问题，最简单的方法就是在创建对象的时候加锁。
1: using System;
2: using System.Collections.Generic;
3: using System.Linq;
4: using System.Text;
5: using System.Threading;
6: using System.Threading.Tasks;
7:
8: namespace SingletonSimpleThreadSafe
9: {
10: public sealed class Singleton
11: {
12: private static Singleton instance = null;
13: private static readonly object _lock = new object();
14:
15: private Singleton()
16: {
17: }
18:
19: public static Singleton Instance
20: {
21: get
22: {
23: lock (_lock)
24: {
25: if (instance == null)
26: {
27: Thread.Sleep(1000);
28: instance = new Singleton();
29: Console.WriteLine(string.Format(
30: "[{0}]创建Singleton {1}", Thread.CurrentThread.ManagedThreadId, instance.GetHashCode()));
31: }
32: }
33:
34: Console.WriteLine(string.Format(
35: "[{0}]获得Singleton {1}", Thread.CurrentThread.ManagedThreadId, instance.GetHashCode()));
36: return instance;
37: }
38: }
39: }
40: }
测试代码如下：
1: using System;
2: using System.Collections.Generic;
3: using System.Linq;
4: using System.Text;
5: using System.Threading;
6: using System.Diagnostics;
7: using System.Threading.Tasks;
8:
9: namespace SingletonSimpleThreadSafe
10: {
11: class Program
12: {
13: private static void Main(string[] args)
14: {
15: SingletonTest();
16: }
17:
18: private static void SingletonTest()
19: {
20: Thread t1 = new Thread(new ThreadStart(Compute));
21:
22: t1.Start();
23:
24: Compute();
25:
26: Console.ReadLine(); // 阻止主线程结束
27: }
28:
29: private static void Compute()
30: {
31: Singleton o1 = Singleton.Instance;
32: }
33: }
34: }
我们再看看执行效果：
创建Singleton只执行一次。但是这种写法性能并不高，每次通过Singleton.Instance获得实例对象都需要判断锁是否别别的线程占用。
这里我们修改一下Singleton，把代码中的Thread.Sleep和Console.Writeline都去掉，这里我重新创建了一个Singleton2 class，两个线程中循环调用100000000次，看一下这么实现的性能：
1: using System;
2: using System.Collections.Generic;
3: using System.Linq;
4: using System.Text;
5: using System.Threading;
6: using System.Threading.Tasks;
7:
8: namespace SingletonSimpleThreadSafe
9: {
10: public sealed class Singleton2
11: {
12: private static Singleton2 instance = null;
13: private static readonly object _lock = new object();
14:
15: private Singleton2()
16: {
17: }
18:
19: public static Singleton2 Instance
20: {
21: get
22: {
23: lock (_lock)
24: {
25: if (instance == null)
26: {
27: instance = new Singleton2();
28: }
29: }
30:
31: return instance;
32: }
33: }
34: }
35: }
测试代码如下：
1: using System;
2: using System.Collections.Generic;
3: using System.Linq;
4: using System.Text;
5: using System.Threading;
6: using System.Diagnostics;
7: using System.Threading.Tasks;
8:
9: namespace SingletonSimpleThreadSafe
10: {
11: class Program
12: {
13: private static void Main(string[] args)
14: {
15: Singleton2Test();
16: }
17:
18: private static void Singleton2Test()
19: {
20: Thread t1 = new Thread(new ThreadStart(Compute2));
21:
22: t1.Start();
23:
24: Compute2();
25:
26: Console.ReadLine(); // 阻止主线程结束
27: }
28:
29: private static void Compute2()
30: {
31: Stopwatch sw1 = new Stopwatch();
32:
33: sw1.Start();
34:
35: for (int i = 0; i < 100000000; i++)
36: {
37: Singleton2 instance = Singleton2.Instance;
38: }
39:
40: sw1.Stop();
41:
42: Console.WriteLine(string.Format("[{0}]耗时：{1}毫秒",
43: Thread.CurrentThread.ManagedThreadId,
44: sw1.ElapsedMilliseconds));
45: }
46: }
47: }
执行结果：
我们先不讨论结果，接着往下看看双检锁方式的性能。
实现3：双检锁实现的线程安全
Singleton双检锁实现：
1: using System;
2: using System.Collections.Generic;
3: using System.Linq;
4: using System.Text;
5: using System.Threading;
6: using System.Threading.Tasks;
7:
8: namespace SingletonDoubleCheckThreadSafe
9: {
10: public sealed class Singleton2
11: {
12: private static Singleton2 instance = null;
13: private static readonly object _lock = new object();
14:
15: private Singleton2()
16: {
17: }
18:
19: public static Singleton2 Instance
20: {
21: get
22: {
23: if (instance == null)
24: {
25: lock (_lock)
26: {
27: if (instance == null)
28: {
29: instance = new Singleton2();
30: }
31: }
32: }
33:
34: return instance;
35: }
36: }
37: }
38: }
测试代码和上面的一样，结果如下：
性能提高了（7571+7465-1410-1412）/ (7571+7465) * 100% = 81.2%。（实际项目中为了减少误差，应该跑多遍测试得到多个结果的平均值和方差，这里为了方便，我只把一次测试结果贴出来。）
双检锁机制在lock外又检查了一次instance是否为null，这样在第一次访问使instance创建后，后面的调用都无需检查lock是否被占用。
一名程序员要了解到这里算基本合格，如果想达到更高的水平，继续往下看。这种方式有什么缺点呢？
- 上面的代码在Java中不能正常工作。这是因为Java的Memory Model实现和.NET不一样，并不保证一定在构造函数执行完成后才返回对象的引用。虽然Java 1.5版本重构了Memory Model，但是双检锁机制在不给instance field加volatile关键字时，依然不能正常工作。
- Microsoft的.net memory model并不是按照标准的ECMA CLI规范实现，而是在标准上做了一些“增强”工作。MS .net CLR memory model中所有的写操作都是VolatileWrite（参考《CLR via C#》第二版的第24章）。所以我们的代码中不加volatile也能在IA64CPU 架构的机器上正常执行。但是如Jeffrey建议，最好还是遵循ECMA标准。
- 实现复杂。
实现4：非懒加载，无锁实现线程安全
.NET中的static变量在class被第一次实例化的时候创建，且保证仅执行一次创建。利用这个特点，可以像如下实现：
1: using System;
2: using System.Collections.Generic;
3: using System.Linq;
4: using System.Text;
5: using System.Threading.Tasks;
6:
7: namespace SingletonNotUsingLock
8: {
9: public class Singleton
10: {
11: private volatile static Singleton instance = new Singleton();
12:
13: // Explicit static constructor to tell C# compiler
14: // not to mark type as beforefieldinit
15: static Singleton()
16: {
17: Console.WriteLine("execute static constructor");
18: }
19:
20: private Singleton()
21: {
22: Console.WriteLine("execute private constructor");
23: }
24:
25: public static Singleton Instance
26: {
27: get
28: {
29: Console.WriteLine("instance get");
30: return instance;
31: }
32: }
33: }
34: }
上面的代码可以更简化一些，去掉Instance属性，将私有的instance变量改成public的：
1: using System;
2: using System.Collections.Generic;
3: using System.Linq;
4: using System.Text;
5: using System.Threading.Tasks;
6:
7: namespace SingletonNotUsingLock
8: {
9: public class Singleton2
10: {
11: public volatile static Singleton2 instance = new Singleton2();
12:
13: // Explicit static constructor to tell C# compiler
14: // not to mark type as beforefieldinit
15: static Singleton2()
16: {
17: Console.WriteLine("execute static constructor");
18: }
19:
20: private Singleton2()
21: {
22: Console.WriteLine("execute private constructor");
23: }
24: }
25: }
代码非常简洁。但是为什么有个静态构造函数呢，我们看看下面的测试代码：
1: using System;
2: using System.Collections.Generic;
3: using System.Linq;
4: using System.Text;
5: using System.Threading.Tasks;
6:
7: namespace SingletonNotUsingLock
8: {
9: class Program
10: {
11: static void Main(string[] args)
12: {
13: Console.WriteLine("begin create singleton");
14:
15: Singleton s1 = Singleton.Instance;
16:
17: Console.WriteLine("after create singleton");
18:
19: Singleton2 s2 = Singleton2.instance;
20:
21: Console.WriteLine("after create singleton2");
22: }
23: }
24: }
执行结果如下：
把静态构造函数去掉后执行结果如下：
这是因为没有静态构造函数的类，编译时会被标记称beforefieldinit，那么，beforefieldinit究竟表示什么样的语义呢？Scott Allen对此进行了详细的解释：beforefieldinit为CLR提供了在任何时候执行.cctor的授权，只要该方法在第一次访问类型的静态字段之前执行即可。
实现5：无锁懒加载
1: using System;
2: using System.Collections.Generic;
3: using System.Linq;
4: using System.Text;
5: using System.Threading.Tasks;
6:
7: namespace SingletonNotUsingLockAndLazyLoad
8: {
9: public class Singleton
10: {
11: private Singleton()
12: {
13: Console.WriteLine("execute Singleton private constructor");
14: }
15:
16: public static Singleton Instance
17: {
18:
19: get
20: {
21: Console.WriteLine("execute Singleton.Instance get");
22: return Nested.instance;
23: }
24: }
25:
26: private class Nested
27: {
28: // Explicit static constructor to tell C# compiler
29: // not to mark type as beforefieldinit
30: static Nested()
31: {
32: Console.WriteLine("execute Nested static constructor");
33: }
34:
35: internal static readonly Singleton instance = new Singleton();
36: }
37: }
38: }
实现6：使用.NET 4.0中的Lazy<T>
1: using System;
2: using System.Collections.Generic;
3: using System.Linq;
4: using System.Text;
5: using System.Threading.Tasks;
6:
7: namespace SingletonUsingLazyType
8: {
9: public sealed class Singleton
10: {
11: private static readonly Lazy<Singleton> lazy =
12: new Lazy<Singleton>(() => new Singleton());
13:
14: public static Singleton Instance { get { return lazy.Value; } }
15:
16: private Singleton()
17: {
18: }
19: }
20: }
参考：
- Exploring the Singleton Design Pattern
- C#设计模式（7）－Singleton Pattern
- Implementing the Singleton Pattern in C#
- c#静态构造函数
- C# and beforefieldinit
- 《研磨设计模式》
- 关于Type Initializer和 BeforeFieldInit的问题，看看大家能否给出正确的解释
- [你必须知道的.NET]第二十三回：品味细节，深入.NET的类型构造器
转载于:https://www.cnblogs.com/EthanCai/p/3150595.html
设计模式之一：单例模式（Singleton Pattern）相关推荐
- 【设计模式】单例模式 Singleton Pattern
通常我们在写程序的时候会碰到一个类只允许在整个系统中只存在一个实例(Instance) 的情况, 比如说我们想做一计数器,统计某些接口调用的次数,通常我们的数据库连接也是只期望有一个实例.Windo ...
- Java设计模式之单例模式(Singleton Pattern)
**单例模式:用来创造独一无二的,只能有一个实例的对象设计模式.单例模式确保一个类只有一个实例,并提供一个全局访问点.**相比于全局变量(对对象的静态引用),单例模式可以延迟实例化,而且全局变量不能保 ...
- 设计模式之单例模式——Singleton
设计模式之单例模式--Singleton 设计意图: 保证类仅有一个实例,并且可以供应用程序全局使用.为了保证这一点,就需要这个类自己创建自己的对象,并且对外有 ...
- Net设计模式实例之单例模式( Singleton Pattern)
一.单例模式简介(Brief Introduction) 单例模式(Singleton Pattern),保证一个类只有一个实例,并提供一个访问它的全局访问点.单例模式因为Singleton封装它的唯 ...
- 单例模式 Singleton Pattern
源地址 单例模式 单例模式(Singleton Pattern)是 Java 中最简单的设计模式之一.这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式. 这种模式涉及到一个单一的类,该 ...
- 设计模式之——单例模式(Singleton)的常见应用场景（转）：
单例模式(Singleton)也叫单态模式,是设计模式中最为简单的一种模式,甚至有些模式大师都不称其为模式,称其为一种实现技巧,因为设计模式讲究对象之间的关系的抽象,而单例模式只有自己一个对象,也因此 ...
- .NET设计模式(1):1.1 单例模式(Singleton Pattern)
概述 单例模式就是保证在整个应用程序的生命周期中,在任何时刻,被指定的类只有一个实例,并为客户程序提供一个获取该实例的全局访问点. 单例模式是一种常用的软件设计模式.在它的核心结构中只包含一个被称为单 ...
- HeaFirst设计模式-单件模式[单例模式](Singleton Pattern)
深入分析单件模式 本次主要介绍的内容有 单件模式 单线程下的单件模式实现 多线程下实现单件模式出现的问题分析 JMM内存模型 多线程下的单件模式实现的三种方式 这些内容,可以从最根本理解单例模式的代码 ...
- Python 设计模式: 单例模式(singleton pattern)
2019独角兽企业重金招聘Python工程师标准>>> 如果想在整个程序的运行过程中,某个类只有一个实例的话,可以通过单例模式来实现. 在 Python 中实现单例模式有很多种方式, ...
- 解读设计模式----单例模式(Singleton Pattern)
单例模式可以保证一个类有且只有一个实例,并提供一个访问它的全局访问点.在程序设计中,有很多情况需要确保一个类只能有一个实例.从这句话可以看出,Singleton模式的核心:如何控制用户使用new对一个 ...
最新文章
- Linux环境编程--进程通信
- Python 多进程开发与多线程开发
- 计算机视觉中的自注意力
- 地球5000年变化全景动画——看完叹了口气：整个世界安静了
- 介绍一下K近邻（KNN）算法，KNeighbors和RadiusNeighbors的差异是什么？各有什么优势？
- matlab、python使用小方法收集
- ICCV 2021 | 重铸Regression荣光！具有残差对数似然估计的人体姿态回归
- 2000以内最好的无人机_全球军用无人机排行榜之国产翔龙无人机
- tableau 实战练习数据源分享_小白入行数据分析师3年-工作内容复盘分享含代码（二）-数据库及Tableau篇介绍...
- mysql udf提权hex_Mysql_UDF提权
- Springboot环境下mybatis配置多数据源配置
- 先导课程 单片机_单片机技术(北京航空航天大学)-壹课堂 - 公开课 | 精品课程 | 教学视频...
- 【Hive】条件函数
- 北京冬奥会交通临时管理措施发布：春节前调休工作日限行
- java 字符串限制长度吗_[Java教程]限制字符串长度
- JNI数据与方法操作实例
- Pyton 类和对象
- Xshell连接虚拟机linux
- 常见的继电接触器控制线路总结
- 各省金融机构存贷款余额、GDP、金融化程度、城镇化率、大专以上人口比重等（2012-2019年）