无废话C#设计模式之二：Singleton

意图

保证一个类只有一个实例，并提供访问它的全局访问点。


场景

我们现在要做一个网络游戏的服务端程序，需要考虑怎么样才能承载大量的用户。在做WEB程序的时候有各种负载均衡的方案，不管是通过硬件实现还是软件实现，基本的思想就是有一个统一的入口，然后由它来分配用户到各个服务器上去。

需要考虑的问题是，即使在多线程的并发状态下，用户只能通过一个唯一的入口来分配，由此引入了Singleton模式来实现这个唯一的入口。
using System;
using System.Collections.Generic;
using System.Threading;

namespace SingletonExample
{
    class Program
    {
        static void Main(string[] args)
        {
            ParameterizedThreadStart ts = new ParameterizedThreadStart(EnterPlayer);//传递参数
            for (int i = 0; i < 20; i++) { Thread t = new Thread(ts);
                t.Start("player" + i);
            }

            LoadBalanceServer.GetLoadBalanceServer().ShowServerInfo();

        }

       static void EnterPlayer(object playerName)
        {
            LoadBalanceServer lbs = LoadBalanceServer.GetLoadBalanceServer();
            lbs.GetLobbyServer().EnterPlayer(playerName.ToString());
        }
    }

    class LoadBalanceServer
    {
        private const int SERVER_COUNT = 3;
        private List<LobbyServer> serverList = new List<LobbyServer>();

        private static volatile LoadBalanceServer lbs;
       private static object syncLock = new object();

        public LoadBalanceServer()
        {
            for (int i = 0; i < SERVER_COUNT; i++)
            {
                serverList.Add(new LobbyServer("LobbyServer" + i));
            }
        }

        public static LoadBalanceServer GetLoadBalanceServer()
        {
            if (lbs == null)
            {
                lock (syncLock)
                {
                    if (lbs == null)
                    {
                        Thread.Sleep(100);
                        lbs = new LoadBalanceServer();
                    }
                }
            }
            return lbs;
        }

        public LobbyServer GetLobbyServer()
        {
            LobbyServer ls = serverList[0];
            for (int i = 1; i < SERVER_COUNT; i++)
            {
                if (serverList[i].PlayerList.Count < ls.PlayerList.Count)
                    ls = serverList[i];
            }
            return ls;
        }

        public void ShowServerInfo()
        {
            foreach (LobbyServer ls in serverList)
            {
                Console.WriteLine("=================" + ls.ServerName + "=================");
                foreach (string player in ls.PlayerList)
                {
                    Console.WriteLine(player);
                }
            }
        }
    }

    class LobbyServer
    {
        private List<string> playerList = new List<string>();

        public List<string> PlayerList
        {
            get { return playerList; }
        }

        private string serverName;

        public string ServerName
        {
            get { return serverName; }
        }

        public LobbyServer(string serverName)
        {
            this.serverName = serverName;
        }

        public void EnterPlayer(string playerName)
        {
            playerList.Add(playerName);
        }
    }
}

代码执行结果如下图：
 


代码说明

LoadBalanceServer类实现了Singleton模式，也就是说无论在什么情况下，只会有一个LoadBalanceServer类的实例出现。

LobbyServer类表示大厅服务，用户进入大厅后和大厅服务进行服务，在这里我们仅仅在大厅服务里面保存了用户列表。

Singleton模式有很多实现方式，在这里使用的是双重锁定方式。对于C#来说，可能使用静态初始化方式是最简洁的，这里就不演示了。

LoadBalanceServer类的GetLobbyServer()方法负责返回一个压力最小的LobbyServer对象。

实例化LoadBalanceServer的时候Sleep了线程，目的是模拟高并发的情况，在正式代码中没有必要这样做。


何时采用

从代码角度来说，当你希望类只有一个实例的时候。

从应用角度来说，你希望有一个总管来负责某一件事情。并且这件事情的分配只能有一个人进行，如果有多个人进行肯定会弄乱。比如创建处理流水号如果有两个地方在创建的话是不是就会重复了呢？


实现要点

一个Singleton类，它能确保自身的实例是唯一的。


注意事项

不要滥用Singleton模式，只有非一个实例不可的情况下才考虑引入Singleton。否则，程序的可扩展性可能会受到限制。