设计模式之Singleton【创建模式】

//单例模式的特点：

//单例类只能有一个实例。

//单例类必须自己创建自己的唯一实例。

//单例类必须给所有其它对象提供这一实例。

//单例模式应用：

//每台计算机可以有若干个打印机，但只能有一个Printer Spooler，避免两个打印作业同时输出到打印机。

//一个具有自动编号主键的表可以有多个用户同时使用，但数据库中只能有一个地方分配下一个主键编号。否则会出现主键重复

//注意：

//不要使用单例模式存取全局变量。这违背了单例模式的用意，最好放到对应类的静态成员中。

//不要将数据库连接做成单例，因为一个系统可能会与数据库有多个连接，并且在有连接池的情况下，应当尽可能及时释放连接。Singleton模式由于使用静态成员存储类实例，所以可能会造成资源无法及时释放，带来问题。

namespace DesignMode

{

    /// <summary>

    /// 单例模式

    /// </summary>

    public class SingleMode

    {

        private static SingleMode single = new SingleMode();

        private SingleMode() {     }

        public static SingleMode getInstance() {

            return single;

        }

    }

    /// <summary>

    /// 考虑线程安全

    /// </summary>

    public class SingleMode2

    {

        private volatile static SingleMode2 single;

        private readonly static object lockhelp = new object();

        private SingleMode2() { }

        public static SingleMode2 getInstance()

        {

            if (single == null)

            {

                lock (lockhelp)

                {

                    if (single == null)

                    {

                        single = new SingleMode2();

                    }

                }

            }

            return single;

        }

    }

}

==========================================================

 

 

class LoadBalancer

 

    {

        // Fields

        private static LoadBalancer balancer;

        private ArrayList servers = new ArrayList();

        private Random random = new Random();

        // Constructors (protected)

        protected LoadBalancer()

        {

            // List of available servers

            servers.Add("ServerI");

            servers.Add("ServerII");

            servers.Add("ServerIII");

            servers.Add("ServerIV");

            servers.Add("ServerV");

            servers.Add("ServerVI");

        }

        // Methods

        public static LoadBalancer GetLoadBalancer()

        {

            // Support multithreaded applications through

            // "Double checked locking" pattern which avoids

            // locking every time the method is invoked

            if (balancer == null)

            {

                // Only one thread can obtain a mutex

                Mutex mutex = new Mutex();

                mutex.WaitOne();

                if (balancer == null)

                    balancer = new LoadBalancer();

                mutex.Close();

            }

            return balancer;

        }

        // Properties

        public string Server

        {

            get

            {

                // Simple, but effective random load balancer

                int r = random.Next(servers.Count);

                return servers[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();

            LoadBalancer b5 = LoadBalancer.GetLoadBalancer();

            LoadBalancer b6 = LoadBalancer.GetLoadBalancer();

            // Same instance?

            if ((b1 == b2) && (b2 == b3) && (b3 == b4))

                Console.WriteLine("Same instance");

            // Do the load balancing

            Console.WriteLine(b1.Server);

            Console.WriteLine(b2.Server);

            Console.WriteLine(b3.Server);

            Console.WriteLine(b4.Server);

            Console.WriteLine(b5.Server);

            Console.WriteLine(b6.Server);

            Console.WriteLine(b4.Server);

            Console.ReadKey();

        }

    }