面试官：平时开发中你用过读写锁吗？

本文转载自微信公众号「精益码农」，作者小码甲。转载本文请联系精益码农公众号。

创新互联建站专业为企业提供崆峒网站建设、崆峒做网站、崆峒网站设计、崆峒网站制作等企业网站建设、网页设计与制作、崆峒企业网站模板建站服务，十多年崆峒做网站经验，不只是建网站，更提供有价值的思路和整体网络服务。

前面实现了一个 带值变更通知能力的字典类(线程不安全)，童鞋们有没有发现演示代码使用了 lock语法糖， 这个有没有问题呢?

没背景说个铲铲

同程艺龙基础架构部推出的数据获取组件DAL.Connection，我们要做到在切换连接配置时清空数据库连接池, 这就涉及到切换连接的时候，触发变更通知。

这在高并发下会有问题：大多数时候下DBA并不会变更业务方的数据库连接，这是一个多读少写的场景， 我们无脑使用lock在多数时间会人为阻塞请求。

到这个时候，我们就要想到读写锁ReaderWriterLockSlim。

宝藏好物：ReaderWriterLockSlim

Use ReaderWriterLockSlim to protect a resource that is read by multiple threads and written to by one thread at a time. ReaderWriterLockSlim allows multiple threads to be in read mode, allows one thread to be in write mode with exclusive ownership of the lock, and allows one thread that has read access to be in upgradeable read mode, from which the thread can upgrade to write mode without having to relinquish its read access to the resource.

简而言之：

ReaderWriterLockSlim提供对某资源在某时刻下的多线程同读 或 单线程独占写。

此外，ReaderWriterLockSlim还提供从读模式无缝升级到独占写模式。

总结下来：

读写锁处于以下四种状态：

1.未进入: 没有线程进入锁(或者所有线程退出锁)

2.读模式：每次调用EnterReadlock时，锁计数都会增加，但允许您读取其中的代码块。

3.写模式：独占、排他

4.可升级的读模式(upgradeable read mode)：多线程读，其中一个线程具备在某时刻升级到排他写模式的可能。

btw，读写锁相比常规lock之外，还具备锁超时的机制，能避免未知原因持续占有锁导致的死锁。

这就很适合我们开发DAL.Connection组件的多读少写的场景。

微软ReaderWriterLockSlim页面还很贴心的给了一个基于读写锁的缓存操作封装类SynchronizedCache。

开箱即用的缓存操作类

基于ReaderWriterLockSlim对线程不安全的Dictionary进行了包装， 可以作为一个多读少写的缓存操作类。

 
 
 
    
  
  
  
  1. public class SynchronizedCache  
    2.   
  
  
  2. { 
    3.   
  
  
  3.     private ReaderWriterLockSlim cacheLock = new ReaderWriterLockSlim(); 
    4.   
  
  
  4.     private Dictionary innerCache = new Dictionary(); 
    5.   
  
  
  5.  
    6.   
  
  
  6.     public int Count 
    7.   
  
  
  7.     { get { return innerCache.Count; } } 
    8.   
  
  
  8.  
    9.   
  
  
  9.     public string Read(int key) 
    10.   
  
  
  10.     { 
    11.   
  
  
  11.         cacheLock.EnterReadLock(); 
    12.   
  
  
  12.         try 
    13.   
  
  
  13.         { 
    14.   
  
  
  14.             return innerCache[key]; 
    15.   
  
  
  15.         } 
    16.   
  
  
  16.         finally 
    17.   
  
  
  17.         { 
    18.   
  
  
  18.             cacheLock.ExitReadLock(); 
    19.   
  
  
  19.         } 
    20.   
  
  
  20.     } 
    21.   
  
  
  21.  
    22.   
  
  
  22.     public void Add(int key, string value) 
    23.   
  
  
  23.     { 
    24.   
  
  
  24.         cacheLock.EnterWriteLock(); 
    25.   
  
  
  25.         try 
    26.   
  
  
  26.         { 
    27.   
  
  
  27.             innerCache.Add(key, value); 
    28.   
  
  
  28.         } 
    29.   
  
  
  29.         finally 
    30.   
  
  
  30.         { 
    31.   
  
  
  31.             cacheLock.ExitWriteLock(); 
    32.   
  
  
  32.         } 
    33.   
  
  
  33.     } 
    34.   
  
  
  34.  
    35.   
  
  
  35.     public bool AddWithTimeout(int key, string value, int timeout) 
    36.   
  
  
  36.     { 
    37.   
  
  
  37.         if (cacheLock.TryEnterWriteLock(timeout)) 
    38.   
  
  
  38.         { 
    39.   
  
  
  39.             try 
    40.   
  
  
  40.             { 
    41.   
  
  
  41.                 innerCache.Add(key, value); 
    42.   
  
  
  42.             } 
    43.   
  
  
  43.             finally 
    44.   
  
  
  44.             { 
    45.   
  
  
  45.                 cacheLock.ExitWriteLock(); 
    46.   
  
  
  46.             } 
    47.   
  
  
  47.             return true; 
    48.   
  
  
  48.         } 
    49.   
  
  
  49.         else 
    50.   
  
  
  50.         { 
    51.   
  
  
  51.             return false; 
    52.   
  
  
  52.         } 
    53.   
  
  
  53.     } 
    54.   
  
  
  54.  
    55.   
  
  
  55.     public AddOrUpdateStatus AddOrUpdate(int key, string value) 
    56.   
  
  
  56.     { 
    57.   
  
  
  57.         cacheLock.EnterUpgradeableReadLock(); 
    58.   
  
  
  58.         try 
    59.   
  
  
  59.         { 
    60.   
  
  
  60.             string result = null; 
    61.   
  
  
  61.             if (innerCache.TryGetValue(key, out result)) 
    62.   
  
  
  62.             { 
    63.   
  
  
  63.                 if (result == value) 
    64.   
  
  
  64.                 { 
    65.   
  
  
  65.                     return AddOrUpdateStatus.Unchanged; 
    66.   
  
  
  66.                 } 
    67.   
  
  
  67.                 else 
    68.   
  
  
  68.                 { 
    69.   
  
  
  69.                     cacheLock.EnterWriteLock(); 
    70.   
  
  
  70.                     try 
    71.   
  
  
  71.                     { 
    72.   
  
  
  72.                         innerCache[key] = value; 
    73.   
  
  
  73.                     } 
    74.   
  
  
  74.                     finally 
    75.   
  
  
  75.                     { 
    76.   
  
  
  76.                         cacheLock.ExitWriteLock(); 
    77.   
  
  
  77.                     } 
    78.   
  
  
  78.                     return AddOrUpdateStatus.Updated; 
    79.   
  
  
  79.                 } 
    80.   
  
  
  80.             } 
    81.   
  
  
  81.             else 
    82.   
  
  
  82.             { 
    83.   
  
  
  83.                 cacheLock.EnterWriteLock(); 
    84.   
  
  
  84.                 try 
    85.   
  
  
  85.                 { 
    86.   
  
  
  86.                     innerCache.Add(key, value); 
    87.   
  
  
  87.                 } 
    88.   
  
  
  88.                 finally 
    89.   
  
  
  89.                 { 
    90.   
  
  
  90.                     cacheLock.ExitWriteLock(); 
    91.   
  
  
  91.                 } 
    92.   
  
  
  92.                 return AddOrUpdateStatus.Added; 
    93.   
  
  
  93.             } 
    94.   
  
  
  94.         } 
    95.   
  
  
  95.         finally 
    96.   
  
  
  96.         { 
    97.   
  
  
  97.             cacheLock.ExitUpgradeableReadLock(); 
    98.   
  
  
  98.         } 
    99.   
  
  
  99.     } 
    100.   
  
  
  100.  
    101.   
  
  
  101.     public void Delete(int key) 
    102.   
  
  
  102.     { 
    103.   
  
  
  103.         cacheLock.EnterWriteLock(); 
    104.   
  
  
  104.         try 
    105.   
  
  
  105.         { 
    106.   
  
  
  106.             innerCache.Remove(key); 
    107.   
  
  
  107.         } 
    108.   
  
  
  108.         finally 
    109.   
  
  
  109.         { 
    110.   
  
  
  110.             cacheLock.ExitWriteLock(); 
    111.   
  
  
  111.         } 
    112.   
  
  
  112.     } 
    113.   
  
  
  113.  
    114.   
  
  
  114.     public enum AddOrUpdateStatus 
    115.   
  
  
  115.     { 
    116.   
  
  
  116.         Added, 
    117.   
  
  
  117.         Updated, 
    118.   
  
  
  118.         Unchanged 
    119.   
  
  
  119.     }; 
    120.   
  
  
  120.  
    121.   
  
  
  121.     ~SynchronizedCache() 
    122.   
  
  
  122.     { 
    123.   
  
  
  123.        if (cacheLock != null) cacheLock.Dispose(); 
    124.   
  
  
  124.     } 
    125.   
  
  
  125. } 
    126.

缓存操作类SynchronizedCache每次操作会返回操作结果，和常见的字典一样，不带值变更通知的能力，我们还是像《面试官：实现一个带值变更通知能力的Dictionary》 一文那样，添加值变更事件，注册变更逻辑。

 
 
 
    
  
  
  
  1. public event EventHandler> OnValueChanged; 
    2.   
  
  
  2.  
    3.   
  
  
  3. //--- 节选自AddOrUpdate方法 
    4.   
  
  
  4. cacheLock.EnterWriteLock(); 
    5.   
  
  
  5. try 
    6.   
  
  
  6. { 
    7.   
  
  
  7.    OnValueChanged?.Invoke(this, new ValueChangedEventArgs(key)); 
    8.   
  
  
  8.    innerCache[key] = value; 
    9.   
  
  
  9. } 
    10.   
  
  
  10. finally 
    11.   
  
  
  11. { 
    12.   
  
  
  12.     cacheLock.ExitWriteLock(); 
    13.   
  
  
  13. } 
    14.   
  
  
  14. return AddOrUpdateStatus.Updated; 
    15.   
  
  
  15.                          
    16.   
  
  
  16. //--- 
    17.   
  
  
  17.  
    18.   
  
  
  18. if (sc.AddOrUpdate(key, value) == SynchronizedCache.AddOrUpdateStatus.Updated) 
    19.   
  
  
  19. { 
    20.   
  
  
  20.     Console.WriteLine($"已经发生了值变更，原key对应的键值已经被重写。");} 
    21.   
  
  
  21. }   
    22.

输出旁白

本文记录了读写锁在日常开发中的实践，大多数场景都是多读少写，读者可以思考一下是不是也可以将项目中的无脑lock替换为SynchronizedCache。

本文是同程艺龙DAL.Connection组件研发过程的一个小插曲，有心的读者可以往上翻一翻，了解上下文背景、了解小码甲的思考过程。

网页题目：面试官：平时开发中你用过读写锁吗？
转载源于：http://www.shufengxianlan.com/qtweb/news35/273485.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站收录知识

各行业网站

西信服务器托管　　 　成都小程序开发　　 　手提袋印刷制作　　 　营销型网站建设　　 　温江电信机房　　 　成都制作网站　　 　成都网站制作　　 　四川艾名斯　　 　德昌麦琪建站　　 　网络推广平台　　 　正泰动物制药　　 　乐山服务器托管　　 　高端网站设计　　 　bgp多线机房托管　　 　网站SEO优化　　 　成都app开发　　 　云服务器香港　　 　微信营销　　 　成都网站设计　　 　四川内江电信机房