Go语言视频零基础入门到精通

admin

1.1.1 摘要
       在我们日常的工作中经常需要在应用程序中保持一个唯一的实例，如：IO处理，数据库操作等，由于这些对象都要占用重要的系统资源，所以我们必须限制这些实例的创建或始终使用一个公用的实例，这就是我们今天要介绍的——单例模式（Singleton）。
       使用频率 高
       单件模式（Singleton）：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
  
1.1.2 正文
  

图1单例模式（Singleton）结构图
  
       单例模式（Singleton）是几个创建模式中最对立的一个，它的主要特点不是根据用户程序调用生成一个新的实例，而是控制某个类型的实例唯一性，通过上图我们知道它包含的角色只有一个，就是Singleton，它拥有一个私有构造函数，这确保用户无法通过new直接实例它。除此之外，该模式中包含一个静态私有成员变量instance与静态公有方法Instance()。Instance()方法负责检验并实例化自己，然后存储在静态成员变量中，以确保只有一个实例被创建。
  

图2单例模式（Singleton）逻辑模型
  
       接下来我们将介绍6中不同的单例模式（Singleton）的实现方式。这些实现方式都有以下的共同点：
  

  
  有一个私有的无参构造函数，这可以防止其他类实例化它，而且单例类也不应该被继承，如果单例类允许继承那么每个子类都可以创建实例，这就违背了Singleton模式“唯一实例”的初衷。  
  单例类被定义为sealed,就像前面提到的该类不应该被继承，所以为了保险起见可以把该类定义成不允许派生，但没有要求一定要这样定义。  
  一个静态的变量用来保存单实例的引用。  
  一个公有的静态方法用来获取单实例的引用，如果实例为null即创建一个。  
  

  
版本一线程不安全
  

1. /// <summary>
2. /// A simple singleton class implements.
3. /// </summary>
4. public sealed class Singleton
5. {
6.     private static Singleton _instance = null;
8.     /// <summary>
9.     /// Prevents a default instance of the
10.     /// <see cref="Singleton"/> class from being created.
11.     /// </summary>
12.     private Singleton()
13.     {
14.     }
16.     /// <summary>
17.     /// Gets the instance.
18.     /// </summary>
19.     public static Singleton Instance
20.     {
21.         get { return _instance ?? (_instance = new Singleton()); }
22.     }
23. }

复制代码

      以上的实现方式适用于单线程环境，因为在多线程的环境下有可能得到Singleton类的多个实例。假如同时有两个线程去判断
（null == _singleton），并且得到的结果为真，那么两个线程都会创建类Singleton的实例，这样就违背了Singleton模式“唯一实例”的初衷。

版本二线程安全

1. /// <summary>
2. /// A thread-safe singleton class.
3. /// </summary>
4. public sealed class Singleton
5. {
6.     private static Singleton _instance = null;
7.     private static readonly object SynObject = new object();
9.     Singleton()
10.     {
11.     }
13.     /// <summary>
14.     /// Gets the instance.
15.     /// </summary>
16.     public static Singleton Instance
17.     {
18.         get
19.         {
20.             // Syn operation.
21.             lock (SynObject)
22.             {
23.                 return _instance ?? (_instance = new Singleton());
24.             }
25.         }
26.     }
27. }

复制代码

        以上方式的实现方式是线程安全的，首先我们创建了一个静态只读的进程辅助对象，由于lock是确保当一个线程位于代码的临界区时，另一个线程不能进入临界区（同步操作）。如果其他线程试图进入锁定的代码，则它将一直等待，直到该对象被释放。从而确保在多线程下不会创建多个对象实例了。只是这种实现方式要进行同步操作，这将是影响系统性能的瓶颈和增加了额外的开销。

Double-Checked Locking
       前面讲到的线程安全的实现方式的问题是要进行同步操作，那么我们是否可以降低通过操作的次数呢？其实我们只需在同步操作之前，添加判断该实例是否为null就可以降低通过操作的次数了，这样是经典的Double-Checked Locking方法。

1. /// <summary>
2. /// Double-Checked Locking implements a thread-safe singleton class
3. /// </summary>
4. public sealed class Singleton
5. {
6.     private static Singleton _instance = null;
7.     // Creates an syn object.
8.     private static readonly object SynObject = new object();
10.     Singleton()
11.     {
12.     }
14.     public static Singleton Instance
15.     {
16.         get
17.         {
18.             // Double-Checked Locking
19.             if (null == _instance)
20.             {
21.                 lock (SynObject)
22.                 {
23.                     if (null == _instance)
24.                     {
25.                         _instance = new Singleton();
26.                     }
27.                 }
28.             }
29.             return _instance;
30.         }
31.     }
32. }

复制代码

      
       在介绍第四种实现方式之前，首先让我们认识什么是，当字段被标记为beforefieldinit类型时，该字段初始化可以发生在任何时候任何字段被引用之前。这句话听起了有点别扭，接下来让我们通过具体的例子介绍。

1. /// <summary>
2. /// Defines a test class.
3. /// </summary>
4. class Test
5. {
6.     public static string x = EchoAndReturn("In type initializer");
8.     public static string EchoAndReturn(string s)
9.     {
10.         Console.WriteLine(s);
11.         return s;
12.     }
13. }

复制代码

      上面我们定义了一个包含静态字段和方法的类Test，但要注意我们并没有定义静态的构造函数。


图3 Test类的IL代码

1. class Test
2. {
3.     public static string x = EchoAndReturn("In type initializer");
5.     // Defines a parameterless constructor.
6.     static Test()
7.     {
8.     }
10.     public static string EchoAndReturn(string s)
11.     {
12.         Console.WriteLine(s);
13.         return s;
14.     }
15. }

复制代码

   
    上面我们给Test类添加一个静态的构造函数。

   
图4 Test类的IL代码

       通过上面Test类的IL代码的区别我们发现，当Test类包含静态字段，而且没有定义静态的构造函数时，该类会被标记为beforefieldinit。
       现在也许有人会问：“被标记为beforefieldinit和没有标记的有什么区别呢”？OK现在让我们通过下面的具体例子看一下它们的区别吧！

1. class Test
2. {
3.     public static string x = EchoAndReturn("In type initializer");
5.     static Test()
6.     {
7.     }
9.     public static string EchoAndReturn(string s)
10.     {
11.         Console.WriteLine(s);
12.         return s;
13.     }
14. }
16. class Driver
17. {
18.     public static void Main()
19.     {
20.         Console.WriteLine("Starting Main");
21.         // Invoke a static method on Test
22.         Test.EchoAndReturn("Echo!");
23.         Console.WriteLine("After echo");
24.         Console.ReadLine();
26.         // The output result:
27.         // Starting Main
28.         // In type initializer
29.         // Echo!
30.         // After echo            
31.     }
32. }

复制代码

     我相信大家都可以得到答案，如果在调用EchoAndReturn()方法之前，需要完成静态成员的初始化，所以最终的输出结果如下：


图5输出结果
    接着我们在Main()方法中添加string y = Test.x，如下：

1. public static void Main()
2. {
3.     Console.WriteLine("Starting Main");
4.     // Invoke a static method on Test
5.     Test.EchoAndReturn("Echo!");
6.     Console.WriteLine("After echo");
8.     //Reference a static field in Test
9.     string y = Test.x;
10.     //Use the value just to avoid compiler cleverness
11.     if (y != null)
12.     {
13.         Console.WriteLine("After field access");
14.     }
15.     Console.ReadKey();
17.     // The output result:
18.     // In type initializer
19.     // Starting Main
20.     // Echo!
21.     // After echo
22.     // After field access
24. }

复制代码

图6 输出结果
        通过上面的输出结果，大家可以发现静态字段的初始化跑到了静态方法调用之前，Wo难以想象啊！
        最后我们在Test类中添加一个静态构造函数如下：

1. class Test
2. {
3.     public static string x = EchoAndReturn("In type initializer");
5.     static Test()
6.     {
7.     }
9.     public static string EchoAndReturn(string s)
10.     {
11.         Console.WriteLine(s);
12.         return s;
13.     }
14. }

复制代码

图7 输出结果

       理论上，type initializer应该发生在”Echo!”之后和”After echo”之前，但这里却出现了不唯一的结果，只有当Test类包含静态构造函数时，才能确保type initializer的初始化发生在”Echo!”之后和”After echo”之前。
所以说要确保type initializer发生在被字段引用时，我们应该给该类添加静态构造函数。接下来让我们介绍单例模式的静态方式。

静态初始化

1. public sealed class Singleton
2. {
3.     private static readonly Singleton _instance = new Singleton();
5.     // Explicit static constructor to tell C# compiler
6.     // not to mark type as beforefieldinit
7.     static Singleton()
8.     {
9.     }
11.     /// <summary>
12.     /// Prevents a default instance of the
13.     /// <see cref="Singleton"/> class from being created.
14.     /// </summary>
15.     private Singleton()
16.     {
17.     }
19.     /// <summary>
20.     /// Gets the instance.
21.     /// </summary>
22.     public static Singleton Instance
23.     {
24.         get
25.         {
26.             return _instance;
27.         }
28.     }
29. }

复制代码

        以上方式实现比之前介绍的方式都要简单，但它确实是多线程环境下，C#实现的Singleton的一种方式。由于这种静态初始化的方式是在自己的字段被引用时才会实例化。
       让我们通过IL代码来分析静态初始化。




图8静态初始化IL代码

        首先这里没有beforefieldinit的修饰符，由于我们添加了静态构造函数当静态字段被引用时才进行初始化，因此即便很多线程试图引用_instance，也需要等静态构造函数执行完并把静态成员_instance实例化之后可以使用。

延迟初始化

1. /// <summary>
2. /// Delaies initialization.
3. /// </summary>
4. public sealed class Singleton
5. {
6.     private Singleton()
7.     {
8.     }
10.     /// <summary>
11.     /// Gets the instance.
12.     /// </summary>
13.     public static Singleton Instance { get { return Nested._instance; } }
15.     private class Nested
16.     {
17.         // Explicit static constructor to tell C# compiler
18.         // not to mark type as beforefieldinit
19.         static Nested()
20.         {
21.         }
23.         internal static readonly Singleton _instance = new Singleton();
24.     }
25. }

复制代码

   这里我们把初始化工作放到Nested类中的一个静态成员来完成，这样就实现了延迟初始化。

Lazy<T> type

1. /// <summary>
2. /// .NET 4"s Lazy<T> type
3. /// </summary>
4. public sealed class Singleton
5. {
6.     private static readonly Lazy<Singleton> lazy =
7.         new Lazy<Singleton>(() => new Singleton());
9.     public static Singleton Instance { get { return lazy.Value; } }
11.     private Singleton()
12.     {
13.     }
14. }

复制代码

     这种方式的简单和性能良好，而且还提供检查是否已经创建实例的属性IsValueCreated。

具体例子
     现在让我们使用单例模式（Singleton）实现负载平衡器，首先我们定义一个服务器类，它包含服务器名和IP地址如下：

1. /// <summary>
2. /// Represents a server machine
3. /// </summary>
4. class Server
5. {
6.     // Gets or sets server name
7.     public string Name { get; set; }
9.     // Gets or sets server IP address
10.     public string IP { get; set; }
11. }

复制代码

     由于负载平衡器只提供一个对象实例供服务器使用，所以我们使用单例模式（Singleton）实现该负载平衡器。

1. /// <summary>
2. /// The "Singleton" class
3. /// </summary>
4. sealed class LoadBalancer
5. {
6.     private static readonly LoadBalancer _instance =
7.         new LoadBalancer();
9.     // Type-safe generic list of servers
10.     private List<Server> _servers;
11.     private Random _random = new Random();
13.     static LoadBalancer()
14.     {
15.     }
17.     // Note: constructor is "private"
18.     private LoadBalancer()
19.     {
20.         // Load list of available servers
21.         _servers = new List<Server>
22.             {
23.               new Server{ Name = "ServerI", IP = "192.168.0.108" },
24.               new Server{ Name = "ServerII", IP = "192.168.0.109" },
25.               new Server{ Name = "ServerIII", IP = "192.168.0.110" },
26.               new Server{ Name = "ServerIV", IP = "192.168.0.111" },
27.               new Server{ Name = "ServerV", IP = "192.168.0.112" },
28.             };
29.     }
31.     /// <summary>
32.     /// Gets the instance through static initialization.
33.     /// </summary>
34.     public static LoadBalancer Instance
35.     {
36.         get { return _instance; }
37.     }
40.     // Simple, but effective load balancer
41.     public Server NextServer
42.     {
43.         get
44.         {
45.             int r = _random.Next(_servers.Count);
46.             return _servers[r];
47.         }
48.     }
49. }

复制代码

  上面负载平衡器类LoadBalancer我们使用静态初始化方式实现单例模式（Singleton）。

1. static void Main()
2. {
3.     LoadBalancer b1 = LoadBalancer.Instance;
4.     b1.GetHashCode();
5.     LoadBalancer b2 = LoadBalancer.Instance;
6.     LoadBalancer b3 = LoadBalancer.Instance;
7.     LoadBalancer b4 = LoadBalancer.Instance;
9.     // Confirm these are the same instance
10.     if (b1 == b2 && b2 == b3 && b3 == b4)
11.     {
12.         Console.WriteLine("Same instance\n");
13.     }
15.     // Next, load balance 15 requests for a server
16.     LoadBalancer balancer = LoadBalancer.Instance;
17.     for (int i = 0; i < 15; i++)
18.     {
19.         string serverName = balancer.NextServer.Name;
20.         Console.WriteLine("Dispatch request to: " + serverName);
21.     }
23.     Console.ReadKey();
24. }

复制代码

图9 LoadBalancer输出结果

1.1.3 总结

单例模式的优点：
单例模式（Singleton）会控制其实例对象的数量，从而确保访问对象的唯一性。

实例控制：单例模式防止其它对象对自己的实例化，确保所有的对象都访问一个实例。  
伸缩性：因为由类自己来控制实例化进程，类就在改变实例化进程上有相应的伸缩性。


单例模式的缺点：

系统开销。虽然这个系统开销看起来很小，但是每次引用这个类实例的时候都要进行实例是否存在的检查。这个问题可以通过静态实例来解决。  
开发混淆。当使用一个单例模式的对象的时候（特别是定义在类库中的），开发人员必须要记住不能使用new关键字来实例化对象。因为开发者看不到在类库中的源代码，所以当他们发现不能实例化一个类的时候会很惊讶。  
对象生命周期。单例模式没有提出对象的销毁。在提供内存管理的开发语言（比如，基于.NetFramework的语言）中，只有单例模式对象自己才能将对象实例销毁，因为只有它拥有对实例的引用。在各种开发语言中，比如C++，其它类可以销毁对象实例，但是这么做将导致单例类内部的指针指向不明。


单例适用性
使用Singleton模式有一个必要条件：在一个系统要求一个类只有一个实例时才应当使用单例模式。反之，如果一个类可以有几个实例共存，就不要使用单例模式。
不要使用单例模式存取全局变量。这违背了单例模式的用意，最好放到对应类的静态成员中。
不要将数据库连接做成单例，因为一个系统可能会与数据库有多个连接，并且在有连接池的情况下，应当尽可能及时释放连接。Singleton模式由于使用静态成员存储类实例，所以可能会造成资源无法及时释放，带来问题。

参考：
http://csharpindepth.com/Articles/General/Singleton.aspx