梦里河 發表於 2020-6-5 08:41:00

C#中的Singleton模式

<p></p><div class="toc"><div class="toc-container-header">目录</div><ul><li>前言</li><li>实现思路</li><li>实现方法<ul><li>最简单的实现方法</li><li>如果多线程乱入？</li><li>线程安全的单例模式<ul><li>Lock版本</li><li>静态构造器版本</li><li>Lazy版本</li></ul></li></ul></li><li>总结</li></ul></div><p></p>
<h1 id="前言">前言</h1>
<p>Singleton是二十三个设计模式中比较重要也比较经常使用的模式。但是这个模式虽然简单，实现起来也会有一些小坑，让我们一起来看看吧！</p>
<h1 id="实现思路">实现思路</h1>
<p>首先我们看看这个设计模式的UML类图。<br>
<img src="https://img2020.cnblogs.com/blog/699616/202006/699616-20200605083551766-381491365.png"></p>
<p>很清晰的可以看到，有三点是需要我们在实现这个模式的时候注意的地方。</p>
<ul>
<li>私有化的构造器</li>
<li>全局唯一的静态实例</li>
<li>能够返回全局唯一静态实例的静态方法</li>
</ul>
<p>其中，私有化构造器是防止外部用户创建新的实例而静态方法用于返回全局唯一的静态实例供用户使用。原理清楚了，接下来我们看看一些典型的实现方式和其中的暗坑。</p>
<h1 id="实现方法">实现方法</h1>
<h2 id="最简单的实现方法">最简单的实现方法</h2>
<p>最简单的实现方法自然就是按照UML类图直接写一个类，我们看看代码。</p>
<pre><code class="language-csharp">    class Program
    {
      static void Main(string[] args)
      {
              var single1 = Singleton.Instance;
            var single2 = Singleton.Instance;
            Console.WriteLine(object.ReferenceEquals(single1, single2));
            Console.ReadLine();
      }
    }

    class Singleton
    {
      private static Singleton _Instance = null;
      private Singleton()
      {
            Console.WriteLine("Created");
      }

      public static Singleton Instance
      {
            get
            {
                if (_Instance == null)
                {
                  _Instance = new Singleton();
                }
                return _Instance;
            }
      }

      public void DumbMethod()
      {

      }
    }
</code></pre>
<p>这段代码忠实的实现了UML类图里面的一切，查看输出结果，</p>
<p><img src="https://img2020.cnblogs.com/blog/699616/202006/699616-20200605083655032-360163328.png"><br>
证实了Singleton确实起了作用，多次调用仅仅产生了一个实例，似乎这么写就可以实现这个模式了。但是，真的会那么简单吗？</p>
<h2 id="如果多线程乱入">如果多线程乱入？</h2>
<p>现在我们给刚刚的例子加点调料，假设多个对实例的调用，并不是简单的，彬彬有礼的顺序关系，二是以多线程的方式调用，那么刚刚那种实现方法，还能从容应对吗？让我们试试。把<strong>Main</strong>函数里面的调用改成这样。</p>
<pre><code class="language-csharp">        static void Main(string[] args)
      {
            int TOTAL = 10000;
            Task[] tasks = new Task;
            for (int i = 0; i &lt; TOTAL; i++)
            {
                tasks = Task.Factory.StartNew(() =&gt;
                {
                  Singleton.Instance.DumbMethod();
                });
            }
                        Task.WaitAll(tasks);
            Console.ReadLine();
      }
</code></pre>
<p>通过Factory创造出1万个Task，几乎同时去请求这个单例，看看输出。<br>
<img src="https://img2020.cnblogs.com/blog/699616/202006/699616-20200605083739568-1051667012.png"></p>
<p>咦，我们刚刚写的Singleton模式失效了，这个类被创造了5次（这段代码运行多次，这个数字不一定相同），一定是多线程搞的鬼，我们刚刚写的代码没有办法应对多线程，换句话说，是非线程安全的(thread-safe)，那有没有办法来攻克这个难关呢？</p>
<h2 id="线程安全的单例模式">线程安全的单例模式</h2>
<h3 id="lock版本">Lock版本</h3>
<p>提到线程安全，很多同学第一反应就是用<strong>lock</strong>，不错，lock是个可行的办法，让我们试试。添加一个引用类型的对象作为lock对象，修改代码如下（什么？你问我为什必须是引用类型的对象而不能是值类型的对象？因为lock的时候，如果对象是值类型，那么lock仅仅锁住了它的一个副本，另外一个线程可以畅通无阻的再次lock，这样lock就失去了阻塞线程的意义）</p>
<pre><code class="language-csharp">        private static object _SyncObj = new object();
      public static Singleton Instance
      {
            get
            {
                lock (_SyncObj)
                {
                  if (_Instance == null)
                  {
                        _Instance = new Singleton();
                  }
                  return _Instance;
                }               
            }
      }
</code></pre>
<p>运行一下，输出<br>
<img src="https://img2020.cnblogs.com/blog/699616/202006/699616-20200605083757095-51529392.png"></p>
<p>只有一个实例创建，证明Lock起作用了，这个模式可行！不过有些不喜欢用Lock的同学可能要问，还有没有其他办法呢？答案是有的。</p>
<h3 id="静态构造器版本">静态构造器版本</h3>
<p>回想一下，C#中的类静态构造器，只会在这个类第一次被使用的时候调用一次，天然的线程安全，那我们试试不用Lock使用类静态构造器？修改Singleton类如下：</p>
<pre><code class="language-csharp">    class Singleton
    {
      private static Singleton _Instance = null;
      private Singleton()
      {
            Console.WriteLine("Created");
      }

      static Singleton()
      {
            _Instance = new Singleton();
      }

      //private static object _SyncObj = new object();
      public static Singleton Instance
      {
            get { return _Instance; }
      }

      public void DumbMethod()
      {

      }
    }
</code></pre>
<p>去掉了Lock，添加了一个类静态构造器，试一试。<br>
<img src="https://img2020.cnblogs.com/blog/699616/202006/699616-20200605083830318-1792528403.png"></p>
<p>完美！对于不喜欢用Lock（在这个例子中，实例只会创建一次但是之后的所有线程都要先排队Lock再进入Critical code进行检查，效率比较低下）的同学，类静态构造器提供了一种很好的选择。<br>
<s>不过俗话说，人心苦不足 ，</s> 我们总是追求卓越。这个版本比Lock版本似乎更好一点，那还有没有更好的版本呢？有的。</p>
<h3 id="lazy版本">Lazy版本</h3>
<p>从net 4.0开始，C#开始支持延迟初始化，通过<strong>Lazy</strong>关键字，我们可以声明某个对象为仅仅当第一次使用的时候，再初始化，如果一直没有调用，那就不初始化，省去了一部分不必要的开销，提升了效率。如果你不熟悉Lazy或者想更多了解它，请参考。我们今天关注的重点在于，Lazy也是天生线程安全的，所以我们尝试用它来实现Singleton模式？修改代码如下：</p>
<pre><code class="language-csharp">    class Singleton
    {
      private static Lazy&lt;Singleton&gt; _Instance = new Lazy&lt;Singleton&gt;(() =&gt; new Singleton());
      private Singleton()
      {
            Console.WriteLine("Created");
      }

      public static Singleton Instance
      {
            get
            {
                return _Instance.Value;
            }
      }

      public void DumbMethod()
      {

      }
    }
</code></pre>
<p>输出结果中可以看到，我们达到了想要的效果：<br>
<img src="https://img2020.cnblogs.com/blog/699616/202006/699616-20200605083848867-1497201027.png"></p>
<p>在上面的代码中，私有变量_Instance现在是被声明为延迟初始化，这样不但天然实现了线程安全，同时在没有调用Instance静态方法的时候（也即没有调用_Instance.Value），初始化不会发生，这样就提高了效率。</p>
<h1 id="总结">总结</h1>
<p>Singleton模式很常见，实现起来也很简单，只是要小心线程安全。以上三种方法都可以实现线程安全的Singleton模式。如果net 版本在4.0之上，建议使用Lazy版本，毕竟对比Lock版本，Lazy版本可以免去实现手动Lock之苦，对比Static版本，又有延迟初始化的性能优势，何乐而不为呢？</p><br><br>
来源：https://www.cnblogs.com/deatharthas/p/13047660.html
頁: [1]
查看完整版本: C#中的Singleton模式