设计模式-单例模式

来源：互联网发布：idle python gui 下载编辑：程序博客网时间：2024/04/27 18:33

单例模式的目的是保证类在系统中只被实例化一次,由该唯一的实例来为系统提供服务.单例模式主要用于保证服务的统一,比如获取统一的编号服务,模仿Oracle的序列生成等.但单例的使用需要谨慎,特别是在需要作负载均衡的地方,因为这种程序级的单例模式实际上只能保证在一个应用中为单例.如果被多个应用加载,还是会被多次实例化.

同时如果采用懒汉式还需要注意线程安全.

多例模式跟单例模式类似,但在实现上要复杂很多,需要维护自己的实例池和分配使用策略,还包括使用状态等的维护,多例模式主要用于有限个资源的管理，

比如数据库连接池等。

下面是单例模式例子:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;
//单例模式：就是保证系统中只实例化一个实例。
namespace MyBaseStudy
{
    //模式1
    class SingleTon_1
    {
        private double _value = 0;
        public double Value
        {
            get
            {
                return _value;
            }
            set
            {
                this._value = value;
            }
        }
        private static SingleTon_1 _instance = new SingleTon_1();
        //在单例模式中需要将构造函数设为Protected或者private，防止其它类来使用构造函数进行实例化。
        private SingleTon_1()
        {
        }
        public static SingleTon_1 GetInstance()
        {
            return _instance;
        }
    }

    //模式2　称为懒汉式，需要保证线程安全
    class SingleTon_2
    {
        private double _value = 0;
        public double Value
        {
            get
            {
                return _value;
            }
            set
            {
                this._value = value;
            }
        }
        private static SingleTon_2 _instance = null;
        private static readonly object padlock = new object();
        //在单例模式中需要将构造函数设为Protected或者private，防止其它类来使用构造函数进行实例化。
        private SingleTon_2()
        {

        }
        //这种缩开销比较大，因为每次进来都需要锁。
        public static SingleTon_2 GetInstanceA()
        {
            lock (padlock)
            {
                if (_instance == null)
                {
                    _instance = new SingleTon_2();
                }
                return _instance;
            }
        }
        //只有在没有实例化的情况下才加锁。
        public static SingleTon_2 GetInstanceB()
        {
            if (_instance == null)
            {
                lock (padlock)
                {
                    if (_instance == null)
                    {
                        _instance = new SingleTon_2();
                    }

                }
            }
            return _instance;
        }
    }

    //一般类
    class CommClass
    {
        private double _value = 0;
        public double Value
        {
            get
            {
                return _value;
            }
            set
            {
                this._value = value;
            }
        }
    }
    //利用泛型来实现单例类的构建，好处是要使用单例模式的类本身可以是普通类,可用于复用。
    public sealed class SingleTon_3<T> where T : new()
    {

        public static T GetInstance()
        {

            return SingleTonCreator.Instance;

        }
        private class SingleTonCreator
        {
            internal static readonly T Instance = new T();
            static SingleTonCreator()
            {
            }

}
}

    public class SingleTonTest
    {
        public static void test()
        {
            SingleTon_1.GetInstance().Value++;
            MessageBox.Show(SingleTon_1.GetInstance().Value.ToString());

SingleTon_1.GetInstance().Value++;
MessageBox.Show(SingleTon_1.GetInstance().Value.ToString());

SingleTon_2.GetInstanceA().Value++;
MessageBox.Show(SingleTon_2.GetInstanceA().Value.ToString());

SingleTon_2.GetInstanceB().Value++;
MessageBox.Show(SingleTon_2.GetInstanceB().Value.ToString());

SingleTon_3<CommClass>.GetInstance().Value++;

MessageBox.Show(SingleTon_3<CommClass>.GetInstance().Value.ToString());

SingleTon_3<CommClass>.GetInstance().Value++;

            MessageBox.Show(SingleTon_3<CommClass>.GetInstance().Value.ToString());
        }
    }
}