C# 锁汇总

一、前言
　　本文章汇总c#中常见的锁，基本都列出了该锁在微软官网的文章，一些不常用的锁也可以参考微软文章左侧的列表，方便温习回顾。
二、锁的分类
2.1、用户模式锁
　　1、volatile 关键字
　　volatile 并没有实现真正的线程同步，操作级别停留在变量级别并非原子级别，对于单系统处理器中，变量存储在主内存中，没有机会被别人修改。但是如果是多处理器，可能就会有问题，因为每个处理器都有单独的data cache，数据更新不一定立刻被写回到主存，可能会造成不同步。
 参考：valatile 微软官网文章。
 
　　2、Spinlock 旋转锁
 　　Spinlock 是内核中提供的一种比较常见的锁机制，自旋锁是“原地等待”的方式解决资源冲突的，即，一个线程获取了一个自旋锁后，另外一个线程期望获取该自旋锁则获取不到，只能够原地“打转”（忙等待）。由于自旋锁的这个忙等待的特性，注定了它使用场景上的限制 ：自旋锁不应该被长时间的持有（消耗 CPU 资源）。
参考：Spinlock 微软官网文章。
 
2.2、内核模式锁
　　1、事件锁
　　自动事件锁：AutoResetEvent
　　WaitOne()进入等待，Set()会释放当前锁给一个等待线程。

1. var are = new AutoResetEvent(true);
2. are.WaitOne();
3. //...
4. are.Set();

复制代码

 
　　手动事件锁：ManualResetEvent
　　WaitOne()进入等待，Set()会释放当前锁给所有等待线程。

1. var mre = new ManualResetEvent(false);
3. mre.WaitOne();//批量拦截，后续的省略号部分是无序执行的。
4. //...
5. mre.Set();//一次释放给所有等待线程

复制代码

参考：ManuaResetEvent 微软官网文章。

　　2、信号量
　　信号量：Semaphore
　　信号量可以控制同时通过的线程数以及总的线程数。

1. //第一个参数表示同时可以允许的线程数，比如1表示每次只允许一个线程通过，
2. //第二个是最大值，比如8表示最多有8个线程。
3. var semaphore = new Semaphore(1, 8);

复制代码

参考：Semaphore 微软官网文章。
 
　　3、互斥锁
　　互斥锁：Mutex
　　Mutex和Monitor很接近，但是没有Monitor.Pulse,Wait,PulseAll的唤醒功能，他的优点是可以跨进程，可以在同一台机器甚至远程机器人的不同进程间共用一个互斥体。

1. var mutex = new Mutex();
2. mutex.WaitOne();
3. //...
4. mutex.ReleaseMutex();

复制代码

 参考：Mutex 微软官网文章。
 
　　4、读写锁
　　读写锁：ReaderWriterLock
　　不要使用ReaderWriterLock，该类有问题（死锁、性能），请使用ReaderWriterLockSlim

.NET Framework有两个读取器-编写器锁，ReaderWriterLockSlim以及ReaderWriterLock。 建议对所有新开发的项目使用 ReaderWriterLockSlim。 虽然 ReaderWriterLockSlim 类似于 ReaderWriterLock，但不同之处在于，前者简化了递归规则以及锁状态的升级和降级规则。 ReaderWriterLockSlim 避免了许多潜在的死锁情况。 另外，ReaderWriterLockSlim 的性能显著优于 ReaderWriterLock。

参考：ReaderWriterLock 微软官网文章。
　　
　　读写锁：ReaderWriterLockSlim

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

复制代码

ReaderWriterLockSlim示例参考：ReaderWriterLockSlim 微软官网文章。
 
2.3、动态计数锁
　　1、动态计数锁：CountdownEvent
　　限制线程数的一个机制，而且这个也是比较常用的（同属于信号量的一种）。

1. var cde = new CountdownEvent(10);
3. //重置当前ThreadCount上限
4. cde.Reset(10);
5. for(int i=0; i<10; i++)
6. {
7.     Task.Factory.StartNew(()=>
8.     {
9.         Thread.Sleep(1000);
10.         SubWoker1();
11.     });
12. }
14. cde.Wait();//相当于Task.WaitAll()
16. cde.Reset(8);
17. for(int i=0; i<8; i++)
18. {
19.     Task.Factory.StartNew(()=>
20.     {
21.         Thread.Sleep(1000);
22.         SubWoker2();
23.     });
24. }
25. cde.Wait();//相当于Task.WaitAll()
27. static void SubWoker1()
28. {
29.     //...
30.     cde.Signal();//将当前的ThreadCount-1操作。
31. }
33. static void SubWoker2()
34. {
35.     //...
36.     cde.Signal();//将当前的ThreadCount-1操作。
37. }
40.             

复制代码

CountdownEvent示例参考：CountdownEvent 微软官网文章。
 
　　2、原子操作类：Interlocked
　　Interlocked类则提供了4种方法进行原子级别的变量操作。Increment , Decrement , Exchange 和CompareExchange 。
　　a、使用Increment 和Decrement 可以保证对一个整数的加减为一个原子操作。
　　b、Exchange 方法自动交换指定变量的值。
　　c、CompareExchange 方法组合了两个操作：比较两个值以及根据比较的结果将第三个值存储在其中一个变量中。
　　d、比较和交换操作也是按原子操作执行的。Interlocked.CompareExchange(ref a, b, c); 原子操作，a参数和c参数比较， 相等b替换a，不相等不替换。
参考：Interlocked 微软官网文章。

2.4、监视锁
　　1、监视锁：Monitor
　　Monitor锁为操作的代码块添加互斥对象，如果A线程正在访问，对象没有到达临界区，则B线程不会访问。
 参考：Monitor 微软官网文章。
 
　　2、监视锁：lock
　　lock锁可以视为monitor锁的语法糖，增加了自动释放机制和异常处理机制。
　　a、不推荐使用lock(this)的方式作为lock锁，因为你不确定别的地方是否重新实例了含有lock的对象。
　　b、不要lock一个字符串。
　　c、不要lock一个外部公开变量。
 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！