本文的概念内容来自深入浅出设计模式一书
由于我在给公司做内培, 所以最近天天写设计模式的文章....
单体模式 Singleton
单体模式的目标就是只创建一个实例.
实际中有很多种对象我们可能只需要它们的一个实例, 例如: 线程池, 缓存, 弹出的对话框, 用于保存设置的类, 用于 logging 的类, 硬件设备驱动对象等等.
一段对话:
A: 如何创建一个对象?
B: new MyObject()
A: 如果想创建另一个对象, 就再次 new MyObject()?
B: 是的
A: 所以说我们有某个类, 我们就可以对它实例化很多次?
B: 是的, 但是它必须是 public 的类额
A: 如果不是 public 的呢?
B: 如果不是 public 的, 那么只有同一个包下的类才能对它实例化, 但是仍然可以实例化多次.
A: 嗯, 很有趣, 你只你可以这样做吗?
B: 没见过, 但是语法是没问题的, 存在即合理.
A: 它是什么意思呢?
B: 我想它不能被实例化吧, 因为它的构造函数是 private 的啊.
A: 那么, 有没有哪个对象可以使用这个 private 的构造函数呢?
B: 额, 我认为只有 MyClass 里面的代码可以调用这个构造函数, 但是感觉那没什么用啊.
A: 为什么没用呢?
B: 因为对类进行实例化, 就是想要用它的实例, 而这样做的话, 别的类也无法对它进行实例化啊. 这是个鸡和蛋的问题: 我可以使用 MyClass 里面的构造函数, 但是我无法实例化这个对象, 因为其他的类无法使用 "new MyClass()".
A: 你着确实是一种观点, 那么下面代码是什么意思呢?
B: MyClass 有一个静态方法, 我们可以这样调用静态方法: MyClass.getInstance();
A: 为什么使用 MyClass, 而不是某个对象的名?
B: 因为 getInstance() 是静态方法; 也就是说, 它是一个类方法, 你需要使用类名来调用方法.
A: 非常有趣, 那么我把实例化代码放里面呢?
B: 确实可以有这种操作...
A: 那么, 现在你认为有第二种方法来实例化对象吗?
B: MyClass.getInstance();
A: 那么你现在能写出只允许创造一个 MyClass 实例的代码了吗?
B: 应该行.
经典单体模式的实现
首先需要有个静态成员变量保留着实例的引用.
然后构造函数必须是私有的.
getInstance() 方法可以该类进行实例化, 并且返回该实例.
另外, 该类也可以有其他方法.
里面最重要的一部分代码:
如果该实例引用为 null, 那么创建一个实例, 并把这个实例赋給类的那个成员变量. 这里要注意, 如果我们永远不需要这个类的实例, 那么这个类永远也不会被实例化, 这叫做懒初始化.
如果实例引用不是 null, 那么就说明之前已经创建过该类的实例了, 那么就返回之前创建的实例就行了.
一道巧克力工厂锅炉的题
先看这个类:
开始的时候, 锅炉是空的, 所以也没有煮沸.
fill() 方法 (填充), 填充锅炉的时候, 锅炉必须是空的, 一旦填满了, 那么 empty 就改为 false, 表示填满了. 刚填满肯定不是煮沸状态, 所以 boiled 也是 false.
drain() 方法 (抽取), 只有锅炉是满的并且煮沸之后才能抽取巧克力液体, 抽取完了, 锅炉就又空了 empty 改为 true.
boil() 方法 (煮), 煮混合液体, 要求锅炉的前提状态必须是满的 empty 为 false, 并且还没煮沸 boiled 为 false. 一旦煮沸了, 就把 boiled 改成 true.
这个工序很好, 但是必须保证只有一个锅炉, 那么该怎么做? 请写出代码.
单体模式定义
单体模式保证一个类只有一个实例, 并提供一个全局访问该实例的方法.
类图:
其他问题
上面巧克力锅炉那道题你可能写好了, 但是可能会出现这个问题:
锅炉可能在里面有液体的情况下又进行了 fill 填充动作. 这是怎么回事?
是不是其他线程引起的这个问题?
我们可能有两个线程都在执行这段代码:
那么两个线程调用时是否有重叠, 代码执行是否有交错? 请看下图:
处理多线程问题
为了解决这个多线程的问题问题, 可已使用 synchronized 方法:
(synchronized 是 java 里的关键字, C# 的请参考下面我写的代码)
使用 synchronized 关键字以后, 每个线程必须等到轮到它的时候才能进入方法. 这样两个线程就不可能同时进入该方法了.
但是这种方法开销很大, 这有时会成为一个问题. 而且可能比你想的更糟糕:
只有第一次执行该方法的时候 synchronized 才起作用, 一旦我们设定好了成员变量那个引用到具体的实例, 以后就不需要 synchronized 这个方法了, 除了第一次, 以后这就是额外的开销.
还能改进多线程吗
1. 如果性能不是那么重要, 就继续使用 synchronized 吧. 但是要记住使用 synchronized 之后运行速度可能会差 100 倍 (JVM).
2. 那就不如早点把实例给创建出来, 而不是懒创建.
例如:
使用静态的成员引用, 这样类在加载的时候就把实例创建出来了 (保证在任何线程访问之前就会创建出来).
3. 使用 "双重检查锁" 来减少对 sync 的使用.
这就是首先检查实例是否被创建了, 如果没有那么进入 sync 块. 第一创建实例的时候时 sync 的, 在块里面, 再检查一次实例是否为 null, 然后创建实例.
volatile 关键字会保证被单体实例化的时候多线程会正确的处理 uniqueInstance 变量.
所以如果性能是问题, 就可以使用这个方法.
其他问题
Q: 如果我创建一个类, 里面都是静态方法和静态变量, 那么它的效果和单体模式不是一样的吗?
A: 是的, 如果你类没有其他依赖并且初始化并不复杂的话.
Q: 可以继承单体模式吗?
A: 简单的回答就是: No.
Q: 为什么单体模式比全局变量好?
A: 全局变量会污染命名空间, 当然了单体模式写不好也很烂.
总结
- C# 实现
- ChocolateBoiler:
- namespace SingletonPattern
- {
- public class ChocolateBoiler
- {
- public bool Empty { get; private set; }
- public bool Boiled { get; private set; }
- private static ChocolateBoiler _uniqueInstance;
- private ChocolateBoiler()
- {
- Empty = true;
- Boiled = false;
- }
- public static ChocolateBoiler GetInstance()
- {
- return _uniqueInstance ?? (_uniqueInstance = new ChocolateBoiler());
- }
- public void Fill()
- {
- if (Empty)
- {
- Empty = false;
- Boiled = false;
- }
- }
- public void Drain()
- {
- if (!Empty && Boiled)
- {
- Empty = true;
- }
- }
- public void Boil()
- {
- if (!Empty && !Boiled)
- {
- Boiled = true;
- }
- }
- }
- }
- SynchronizedChocolateBoiler:
- using System.Runtime.CompilerServices;
- namespace SingletonPattern
- {
- public class SynchronizedChocolateBoiler
- {
- public bool Empty { get; private set; }
- public bool Boiled { get; private set; }
- private static SynchronizedChocolateBoiler _uniqueInstance;
- private SynchronizedChocolateBoiler()
- {
- Empty = true;
- Boiled = false;
- }
- [MethodImpl(MethodImplOptions.Synchronized)]
- public static SynchronizedChocolateBoiler GetInstance()
- {
- return _uniqueInstance ?? (_uniqueInstance = new SynchronizedChocolateBoiler());
- }
- public void Fill()
- {
- if (Empty)
- {
- Empty = false;
- Boiled = false;
- }
- }
- public void Drain()
- {
- if (!Empty && Boiled)
- {
- Empty = true;
- }
- }
- public void Boil()
- {
- if (!Empty && !Boiled)
- {
- Boiled = true;
- }
- }
- }
- }
- DoubleCheckChocolateBoiler:
- namespace SingletonPattern
- {
- public class DoubleCheckChocolateBoiler
- {
- public bool Empty { get; private set; }
- public bool Boiled { get; private set; }
- private static volatile DoubleCheckChocolateBoiler _uniqueInstance;
- private static readonly object LockHelper = new object();
- private DoubleCheckChocolateBoiler()
- {
- Empty = true;
- Boiled = false;
- }
- public static DoubleCheckChocolateBoiler GetInstance()
- {
- if (_uniqueInstance == null)
- {
- lock (LockHelper)
- {
- if (_uniqueInstance == null)
- {
- _uniqueInstance = new DoubleCheckChocolateBoiler();
- }
- }
- }
- return _uniqueInstance;
- }
- public void Fill()
- {
- if (Empty)
- {
- Empty = false;
- Boiled = false;
- }
- }
- public void Drain()
- {
- if (!Empty && Boiled)
- {
- Empty = true;
- }
- }
- public void Boil()
- {
- if (!Empty && !Boiled)
- {
- Boiled = true;
- }
- }
- }
- }
这个系列的代码我放在这里了: https://github.com/solenovex/Head-First-Design-Patterns-in-CSharp
来源: https://www.cnblogs.com/cgzl/p/8793447.html