c#多线程同步之lock

   一提起lock,想必大家都很熟悉,因为它易用,顾名思义,就是一把锁,常用于多线程的同步,一次只允许一个线程进入。最近遇到一个很诡异的bug。

  

 1         private static readonly object lock4 = new object();
 2 
 3         private static void LoadResolvers(string name)
 4         {
 5             if (resolvesCache.Count == 0)
 6             {
 7 
 8 #if DEBUG
 9                 Console.WriteLine(name+",进入第一层判断,当前解析器数:" + resolvesCache.Count + ",时间:" + DateTime.Now.ToShortTimeString());
10 #endif
11 
12                 lock (lock4)
13                 {
14 
15                     if (resolvesCache.Count == 0)
16                     {
17 
18 #if DEBUG
19                         Console.WriteLine(name + ",进入第二层判断,当前解析器数:" + resolvesCache.Count + ",时间:" + DateTime.Now.ToShortTimeString());
20 #endif
21 
22 
23                         List<Resolvers> listResolvers = ResolversBLL.GetAllResolvers();
24 
25 
26 #if DEBUG
27                         Console.WriteLine(name + ",解析器查询完,准备遍历,查询出的解析器数:" + listResolvers.Count+ ",当前解析器数:" + resolvesCache.Count + ",时间:" + DateTime.Now.ToShortTimeString());
28 #endif
29 
30                         foreach (Resolvers resolver in listResolvers)
31                         {
32                             List<ResolverConfigures> listConfigures = ResolverConfiguresBLL.GetResolverConfiguresByResolverId(resolver.ResolverID);
33 
34                             LoginInfo loginInfo = LoginInfoDAL.SelectItemByItemId(resolver.ResolverID);
35 
36                             NameValueCollection valueCollection = new NameValueCollection();
37 
38                             if (loginInfo != null)
39                             {
40                                 valueCollection.Add("username", loginInfo.UserName);
41                                 valueCollection.Add("password", loginInfo.Password);
42                             }
43 
44                             foreach (ResolverConfigures configures in listConfigures)
45                             {
46                                 if (!string.IsNullOrEmpty(configures.Key))
47                                     valueCollection.Add(configures.Key, configures.Value);
48                             }
49 
50                             if (!resolvesCache.ContainsKey(resolver))
51                             {
52                                 resolvesCache.Add(resolver, valueCollection);
53                             }
54                         }
55 
56 #if DEBUG
57                         Console.WriteLine(name + ",遍历完解析器并添加完成,当前解析器数:" + resolvesCache.Count + ",时间:" + DateTime.Now.ToShortTimeString());
58 #endif
59 
60                     }
61                 }
62             }
63         }

     这段代码的大意:从数据库中查询出解析器(23行)加入到解析器缓存中(52行)。这个牵扯到多线程,因此,第12行加了把锁。本来数据库中只有13条数据,但是软件启动后,缓存中添加了26条数据,这是为什么呢?明明double  if判断,lock每次只允许一个线程进入。

                                                            图1

 

     为了搞清楚事情的真相,我写了个控制台代码:

 1  private static Dictionary<string, string> resolvesCache = new Dictionary<string, string>();
 2         public static Dictionary<string, string> ResolvesCache
 3         {
 4             get
 5             {
 6                 if (resolvesCache.Count == 0)
 7                 {
 8                     LoadResolvers();
 9                 }
10 
11                 return resolvesCache;
12             }
13             set
14             {
15                 resolvesCache = value;
16             }
17         }
18 
19         private static void LoadResolvers()
20         {
21             if (resolvesCache.Count == 0)
22             {
23                 lock (resolvesCache)
24                 {
25                     Thread.Sleep(new Random().Next(1000, 3000));
26 
27                     for (int i = 0; i < 13; i++)
28                     {
29                         string key = i + DateTime.Now.Millisecond.ToString();
30 
31                         if (!resolvesCache.ContainsKey(key))
32                         {
33                             resolvesCache.Add(key, "wbq");
34                         }
35                     }
36                 }
37             }
38         }
39 
40 
41 
42         static void Main(string[] args)
43         {
44 
45             Thread thread1 = new Thread(new ThreadStart(() =>
46                 {
47                     Console.WriteLine("线程1:" + ResolvesCache.Count.ToString());
48 
49                 }));
50 
51             thread1.Start();
52 
53 
54             Thread thread2 = new Thread(new ThreadStart(() =>
55             {
56 
57                 LoadResolvers();
58                 Console.WriteLine("线程2:" + ResolvesCache.Count.ToString());
59 
60             }));
61 
62             thread2.Start();
63 
64 
65             Thread thread3 = new Thread(new ThreadStart(() =>
66             {
67                 LoadResolvers();
68                 Console.WriteLine("线程3:" + ResolvesCache.Count.ToString());
69 
70             }));
71 
72             thread3.Start();

运行结果:

每次一个线程访问下缓存,缓存数据加倍变化,这是为什么呢?哦,别忘了double if判断。因为程序刚运行,三个线程几乎同时到达22行,过了第一个if。这好比,很多人在公司外面等着面试,大家赶时间点几乎同时到,但是面试是一对一进行,这时候需要等待。在24行之后,再加一个if判断:

运行结果:

这下跟正式代码一样了吧。都是double if 判断,测试代码达到要求了,为什么正式代码有问题呢?为了研究,在正式的代码上加上了好多debug,让它输出当前线程名称,记录相关日志。

从图1的日志上可以看出,这是同一个线程所为。为什么会执行两遍呢?

再看看23行代码:

List<Resolvers> listResolvers = ResolversBLL.GetAllResolvers();

跟进到 ResolversBLL类中,发现了一句代码:

 private static OfficialMetadataResolveManager resolverManager = new OfficialMetadataResolveManager(BibliographyAutoUpdateProcess.ResolvesCache);

静态对象,类加载的时候,首先访问。 这不是解析器缓存的访问器吗?看看它的实现:

 1  private static Dictionary<Resolvers, NameValueCollection> resolvesCache = new Dictionary<Resolvers, NameValueCollection>();
 2 
 3         public static Dictionary<Resolvers, NameValueCollection> ResolvesCache
 4         {
 5             get
 6             {
 7                 if (resolvesCache.Count == 0)
 8                 {
 9                     LoadResolvers(Thread.CurrentThread.Name);
10                 }
11 
12                 return resolvesCache;
13             }
14             set
15             {
16                 resolvesCache = value;
17             }
18         }

第9行调用了 LoadResolvers,当前线程正在执行LoadResolvers方法,中途调用解析器缓存访问器,结果解析器缓存访问器又调用了此访问。所以这段代码执行了两次,因此,数据翻倍。终于真相大白了。

要修改其实也很简单,把第二个if判断,放到数据库查询解析器之后即可。这样的话,等于数据库查询了两次,但是缓存中只缓存一份数据。

 

转载于:https://www.cnblogs.com/wangqiang3311/p/8067080.html

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值