关于多线程锁的问题。

Question

在主线程中定义了 public static IList<Model.Keyword_Model> StaticMList = new List<Model.Keyword_Model>();
 private static Object thisLock = new Object();
在子线程中：
      for (int i = 0; i < Keywordtype.Length; i++)
                        {
                            Model.Keyword_Model MModel = new jingjiaprj.Model.Keyword_Model();
                           //给MModel赋值                            AddMlist(MModel);
                           
                        }       public static void AddMlist(Model.Keyword_Model mmodel)
        {
            lock (thisLock)
            {
                StaticMList.Add(mmodel);
            }
        }这样锁有问题。我得出来的结果StaticMList里的结果都是重复的。这是为什么？
希望哪位高手能帮忙解答下

Answer 1

有其他地方操作StaticMList吗？
就你的代码来看，锁没有必要存在。

Answer 2

在子线程中给StaticMList赋好值后，在主线程中有输出操作，而且子线程有多个，对同一变量赋值是难道不应该加锁吗？

Answer 3

private static Object thisLock = new Object();
这个是在哪里，是在你的类中，还是一个全局的，如果在你的Model.Keyword_Model中，那么每次new，lock的都是自己内部的，不是公共的

Answer 4

是跟public static void AddMlist方法在同一个类中。

Answer 5

要用到单例模式最好在static前加readonly，实例化一次就不能变了，这样加锁其实不是很安全，最好用你的类实例控制下，用一个嵌套子类做限定，对效率方面都有帮助，形如下。
    public sealed class SingleTon
    {
       private  static SingleTon clone = null;
       /// <summary>
       ///  /// <summary>
       /// 辅助锁对象，本身没有意义 
       /// </summary>
       /// </summary>
       private static readonly object obj = new object();
        public static SingleTon Clone
       {
           get
           {
               if (clone == null)
               {
                   lock (obj)
                    {
                        clone = Nested.Clone;
                        return clone;
                    }
                 
               }
               return clone;
           }
       }
         class Nested///嵌套类延时实例化。
       {
           static Nested()
           {
           }
           internal static readonly SingleTon Clone = new SingleTon();
       }
    }

Answer 6

这个需要看看单实例模式中的多线程，一般的写法会用的双重锁定
参考如下：
public sealed class Singleton
 {
     static Singleton instance=null;
     static readonly object padlock = new object();
 
     Singleton()
     {
     }
 
    public static Singleton Instance
    {
        get
        {
            if (instance==null)
            {
                lock (padlock)
                {
                    if (instance==null)
                    {
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }
    }
}

Answer 7

看不懂一堆乱七八糟的描述。就不扣抠细节上的严重概念混乱了，单说你的lock。既然你是在“子线程中”顺序去操作，那么根本没有什么并发操作，毫无必要lock。不要因为线程这个词比较好听，就一定要用lock来点缀啊。