笔记(NS)篇-单例模式（Singleton）

笔记(NS)篇-单例模式（Singleton）

签名：你存在的价值，取决于能否解决相关的问题。

• 单例模式的特点
• 应用场景
• 代码演示
• 其他参考写法

单例模式的特点

1、在某种程度上，单例模式（Singleton）是限制而不是改进类的创建；
2、单例模式可以保证一个类有且只有一个实例；
3、提供一个访问它的全局访问点。

应用场景

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

代码演示

下面通过Singleton设计模式代码演示了负载均衡实例对象。在负载均衡模型中，有多台服务器提供服务，任务分配器随机挑选一台服务器提供服务，以确保任务均衡（实际情况比这个复杂的多），这里，任务分配实例只能有一个，负责挑选服务器并分配任务。程序主要代码如下：

using System;
using System.Collections;
using System.Threading;

namespace Singleton
{
    /// <summary>
    /// 负载均衡类
    /// </summary>
    class LoadBalancer
    {
        private static LoadBalancer loadBalancer;
        private ArrayList ArrayList_Server = new ArrayList();
        private Random random = new Random();
        protected LoadBalancer()                                            //构造函数
        {
            ArrayList_Server.Add("Server 1");
            ArrayList_Server.Add("Server 2");
            ArrayList_Server.Add("Server 3");
            ArrayList_Server.Add("Server 4");
        }
        public static LoadBalancer GetLoadBalancer()                        //创建实例的唯一入口
        {
            if (loadBalancer == null)                                       //静态变量为空
            {
                Mutex mutex = new Mutex();                                  //创建互斥体
                mutex.WaitOne();                                            //防止多用户并发操作
                if (loadBalancer == null)
                    loadBalancer = new LoadBalancer();                      //创建类的实例
                mutex.Close();                                              //关闭互斥体
            }
            return loadBalancer;
        }
        public string Server
        {
            get
            {
                int r = random.Next(ArrayList_Server.Count);
                return ArrayList_Server[r].ToString();
            }
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            LoadBalancer b1 = LoadBalancer.GetLoadBalancer();               //创建类的实例
            LoadBalancer b2 = LoadBalancer.GetLoadBalancer();
            LoadBalancer b3 = LoadBalancer.GetLoadBalancer();
            LoadBalancer b4 = LoadBalancer.GetLoadBalancer();
            if ((b1 == b2) && (b2 == b3) && (b3 == b4))                     //判断实例是否相同
            {
                Console.WriteLine("同步运行相同的实例对象");
            }
            Console.WriteLine(b1.Server);
            Console.WriteLine(b2.Server);
            Console.WriteLine(b3.Server);
            Console.WriteLine(b4.Server);
            Console.ReadKey();
        }
    }
}

其他参考写法

这里要说的是，关于线程安全问题，除了使用Mutex进行防止并发操作外，还可以使用lock实现。

 public class MyCore
    {
        private static MyCore uniqueInstance;
        //定义一个线程同步，使外界不能创建该类实例
        private static readonly object locker = new object();
        private MyCore()
        {
        }
        public static MyCore GetInstance()
        {
            if (uniqueInstance == null)
            {
                lock (locker)
                {
                    if (uniqueInstance == null)
                    {
                        uniqueInstance = new MyCore();
                    }
                }
            }
            return uniqueInstance;
        }

    }

c#语言的特性决定了c#拥有实现Singleton模式的独特方法。不详细解释，给出一个例子。

    public sealed class Singleton
    {
        Singleton() { }         //构造函数
        public static Singleton GetInstance()
        {
            return Nested.instance;
        }

        class Nested
        {
            static Nested() { }
            internal static readonly Singleton instance = new Singleton();
        }

    }

这样虽然代码很少，但解决了线程性能上的损失。工作原理是，Singleton类被声明为sealed，不会用于被继承，将成员变量Instance声明为public readonly，并在声明时被初始化。通过这些改变，确实得到了Singleton的设计模式，原因是在JIT的处理过程中如果类中的static属性被任何方法使用时，.NET Framework将对这个属性进行初始化，于是在初始化Instance属性的同时Singleton类实例得以创建和装载。而私有的构造函数和readonly关键字保证了singleton不会被再次实例化，这正是singleton设计模式的意图。