C#中的lock关键字;就是lock住一个大家都共同访问的（静态static的）东东就行了

public class ChatService : IChat //继承IChat接口或者说IChat的实现类
    {
        //定义一个静态对象用于线程部份代码块的锁定，用于lock操作
        private static Object syncObj = new Object();
       

  //创建一个静态Dictionary（表示键和值）集合(字典)，用于记录在线成员，Dictionary<(Of <(TKey, TValue>)>) 泛型类
        static Dictionary<string, ChatEventHandler> chatters = new Dictionary<string, ChatEventHandler>();
       

  //成员进入聊天室
        public string[] Join(string name)
        {
           //锁定，保持lock块中的代码段始终只有一个线程在调用，原因是ConcurrencyMode.Multiple 为异步的多线程实例，存在并发竞争问题
            //如果不锁定，则静态成员字典chatters.ContainsKey(name) 的结果将会不确定，原因是每个线程都可以访问到它。以下凡是chatters 的操作匀加锁
            //使用lock多个线程同时请示时，没有操作权的将会在线程池中等待至有操作权的线程执完成。lock 方法存在影响吞吐量的问题
            lock (syncObj)
            {
                //如果请求的昵称在成员字典中不存在并不空
                if (!chatters.ContainsKey(name) && name != "" && name != null)
                {
                 chatters.Add(name, MyEventHandler);//加入到成员字典key 为当前昵称，MyEventHandler 当前的委托调用                    
                }
            }
}

上面的是别人的版本,我的如下

 

 public  class KeyController
    {

        private static Dictionary<string, List<string>> KeyCache = new Dictionary<string, List<string>>();

        private static object _lockKeyController = new object();

        #region 班级老师key
        /// <summary>
        /// 获取班级老师的所有key
        /// </summary>
        /// <param name="classId"></param>
        /// <returns></returns>
        public static List<string> GetClassTeacherKeysByClassId(Int64 classId)
        {
            string key = string.Format(CacheKey.ClassTeacherKeysByClassId, classId);
            lock (_lockKeyController)
            {
                if (KeyCache.ContainsKey(key))
                {
                    return KeyCache[key];
                }
                else
                {
                    List<string> keyList = new List<string>();
                    List<Teacher> tList = ClassController.GetClassTeachers(classId);
                    foreach (Teacher model in tList)
                    {
                        keyList.Add(string.Format(CacheKey.CacheTeacher, model.Uid, classId));
                    }
                    KeyCache.Add(key, keyList);
                    return keyList;
                }
            }
            
        }
        /// <summary>
        /// 当有班级老师发生添加或删除时调用该方法，删除班级老师的所有key
        /// </summary>
        /// <param name="classId"></param>
        public static void RemoveClassTeacherKeys(Int64 classId)
        {
            string key = string.Format(CacheKey.ClassTeacherKeysByClassId, classId);
            lock (_lockKeyController)
            {
                if (KeyCache.ContainsKey(key))
                {
                    KeyCache.Remove(key);
                }
            }
            
        }
        #endregion
}

首先给出MSDN的定义：

lock 关键字可以用来确保代码块完成运行，而不会被其他线程中断。这是通过在代码块运行期间为给定对象获取互斥锁来实现的。

先来看看执行过程，代码示例如下：

假设线程A先执行，线程B稍微慢一点。线程A执行到lock语句，判断obj是否已申请了互斥锁，

判断依据是逐个与已存在的锁进行object.ReferenceEquals比较（此处未加证实），如果不存

在，则申请一个新的互斥锁，这时线程A进入lock里面了。

这时假设线程B启动了，而线程A还未执行完lock里面的代码。线程B执行到lock语句，检查到obj

已经申请了互斥锁，于是等待；直到线程A执行完毕，释放互斥锁，线程B才能申请新的互斥锁并执行

lock里面的代码。