通用公共类Common.(Singleton)--单件模式,线程锁

单件模式 确保一个类型只有一个实例

实现的步骤：

将类声明为sealed 阻止其被继承 以及 将构造函数声明为私有阻止其被实例化

保证了其只能被做为静态类访问，以及全局实例的唯一性

通过 public static T GetInstance()

获得泛型的唯一实例的引用，若引用为空，则创建新实例new T()

 

    /// <summary>
    /// Singleton泛型类
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public sealed class Singleton<T> where T : new()
    {
        private static T instance = new T();

        private static object lockHelper = new object();
      
        /// <summary>
        /// 构造函数
        /// </summary>
        private Singleton() 
        { }

        /// <summary>
        /// 获取实例
        /// </summary>
        /// <param name="value"></param>
        public static T GetInstance()
        {
            if (instance == null)      //注意此处两此判断instance==null，防止每次访问此方法时都是用lock
            {
                lock (lockHelper)
                {
                    if (instance == null) //第二次
                    {
                        instance = new T();
                    }
                }
            }

            return instance;
        }

        /// <summary>
        /// 设置实例
        /// </summary>
        /// <param name="value"></param>
        public static void SetInstance(T value)
        {
            instance = value;
        }
        
    }

 

 

lock 关键字可确保当一个线程位于代码的临界区时，另一个线程不会进入该临界区。 如果其他线程试图进入锁定的代码，则它将一直等待（即被阻止），直到该对象被释放。

 

lock 关键字在块的开始处调用 Enter，而在块的结尾处调用 Exit。

通常，应避免锁定 public 类型，否则实例将超出代码的控制范围。 常见的结构 lock (this)、lock (typeof (MyType)) 和 lock ("myLock") 违反此准则：

• 如果实例可以被公共访问，将出现 lock (this) 问题。

• 如果 MyType 可以被公共访问，将出现 lock (typeof (MyType)) 问题。

• 由于进程中使用同一字符串的任何其他代码都将共享同一个锁，所以出现 lock(“myLock”) 问题。

最佳做法是定义 private 对象来锁定, 或 private static 对象变量来保护所有实例所共有的数据。