這篇文章向大家介紹了讀寫鎖ReaderWriterLockSlim，其優點就是多個線程可以同時讀取該對象，要了解更多讀寫鎖的知識，仔細閱讀下文吧

讀寫鎖的概念很簡單，允許多個線程同時獲取讀鎖，但同一時間只允許一個線程獲得寫鎖，因此也稱作共享-獨占鎖。在C#中，推薦使用ReaderWriterLockSlim類來完成讀寫鎖的功能。

某些場合下，對一個對象的讀取次數遠遠大于修改次數，如果只是簡單的用lock方式加鎖，則會影響讀取的效率。而如果采用讀寫鎖，則多個線程可以同時讀取該對象，只有等到對象被寫入鎖占用的時候，才會阻塞。

簡單的說，當某個線程進入讀取模式時，此時其他線程依然能進入讀取模式，假設此時一個線程要進入寫入模式，那么他不得不被阻塞。直到讀取模式退出為止。

同樣的，如果某個線程進入了寫入模式，那么其他線程無論是要寫入還是讀取，都是會被阻塞的。

進入寫入/讀取模式有2種方法：

EnterReadLock嘗試進入寫入模式鎖定狀態。

TryEnterReadLock(Int32) 嘗試進入讀取模式鎖定狀態，可以選擇整數超時時間。

EnterWriteLock 嘗試進入寫入模式鎖定狀態。

TryEnterWriteLock(Int32) 嘗試進入寫入模式鎖定狀態，可以選擇超時時間。

退出寫入/讀取模式有2種方法：

ExitReadLock 減少讀取模式的遞歸計數，并在生成的計數為 0(零)時退出讀取模式。

ExitWriteLock 減少寫入模式的遞歸計數，并在生成的計數為 0(零)時退出寫入模式。

下面演示一下用法：

1. public class Program 
2. { 
3. static private ReaderWriterLockSlim rwl = new ReaderWriterLockSlim(); 
4. static void Main(string[] args) 
5. { 
6. Thread t_read1 = new Thread(new ThreadStart(ReadSomething)); 
7. t_read1.Start(); 
8. Console.WriteLine("{0} Create Thread ID {1} , Start ReadSomething", DateTime.Now.ToString("hh:mm:ss fff"), t_read1.GetHashCode()); 
9. Thread t_read2 = new Thread(new ThreadStart(ReadSomething)); 
10. t_read2.Start(); 
11. Console.WriteLine("{0} Create Thread ID {1} , Start ReadSomething", DateTime.Now.ToString("hh:mm:ss fff"), t_read2.GetHashCode()); 
12. Thread t_write1 = new Thread(new ThreadStart(WriteSomething)); 
13. t_write1.Start(); 
14. Console.WriteLine("{0} Create Thread ID {1} , Start WriteSomething", DateTime.Now.ToString("hh:mm:ss fff"), t_write1.GetHashCode()); 
15. } 
16. static public void ReadSomething() 
17. { 
18. Console.WriteLine("{0} Thread ID {1} Begin EnterReadLock...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode()); 
19. rwl.EnterReadLock(); 
20. try 
21. { 
22. Console.WriteLine("{0} Thread ID {1} reading sth...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode()); 
23. Thread.Sleep(5000);//模擬讀取信息 
24. Console.WriteLine("{0} Thread ID {1} reading end.", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode()); 
25. } 
26. finally 
27. { 
28. rwl.ExitReadLock(); 
29. Console.WriteLine("{0} Thread ID {1} ExitReadLock...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode()); 
30. } 
31. } 
32. static public void WriteSomething() 
33. { 
34. Console.WriteLine("{0} Thread ID {1} Begin EnterWriteLock...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode()); 
35. rwl.EnterWriteLock(); 
36. try 
37. { 
38. Console.WriteLine("{0} Thread ID {1} writing sth...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode()); 
39. Thread.Sleep(10000);//模擬寫入信息 
40. Console.WriteLine("{0} Thread ID {1} writing end.", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode()); 
41. } 
42. finally 
43. { 
44. rwl.ExitWriteLock(); 
45. Console.WriteLine("{0} Thread ID {1} ExitWriteLock...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode()); 
46. } 
47. } 
48. } 

可以看到3號線程和4號線程能夠同時進入讀模式，而5號線程過了5秒鐘后(即3,4號線程退出讀鎖后)，才能進入寫模式。

把上述代碼修改一下，先開啟2個寫模式的線程，然后在開啟讀模式線程，代碼如下：

1. static void Main(string[] args) 
2. { 
3. Thread t_write1 = new Thread(new ThreadStart(WriteSomething)); 
4. t_write1.Start(); 
5. Console.WriteLine("{0} Create Thread ID {1} , Start WriteSomething", DateTime.Now.ToString("hh:mm:ss fff"), t_write1.GetHashCode()); 
6. Thread t_write2 = new Thread(new ThreadStart(WriteSomething)); 
7. t_write2.Start(); 
8. Console.WriteLine("{0} Create Thread ID {1} , Start WriteSomething", DateTime.Now.ToString("hh:mm:ss fff"), t_write2.GetHashCode()); 
9. Thread t_read1 = new Thread(new ThreadStart(ReadSomething)); 
10. t_read1.Start(); 
11. Console.WriteLine("{0} Create Thread ID {1} , Start ReadSomething", DateTime.Now.ToString("hh:mm:ss fff"), t_read1.GetHashCode()); 
12. Thread t_read2 = new Thread(new ThreadStart(ReadSomething)); 
13. t_read2.Start(); 
14. Console.WriteLine("{0} Create Thread ID {1} , Start ReadSomething", DateTime.Now.ToString("hh:mm:ss fff"), t_read2.GetHashCode()); 
15. } 

結果如下：

可以看到，3號線程和4號線程都要進入寫模式，但是3號線程先占用寫入鎖，因此4號線程不得不等了10s后才進入。5號線程和6號線程需要占用讀取鎖，因此等4號線程退出寫入鎖后才能繼續下去。

TryEnterReadLock和TryEnterWriteLock可以設置一個超時時間，運行到這句話的時候，線程會阻塞在此，如果此時能占用鎖，那么返回true，如果到超時時間還未占用鎖，那么返回false，放棄鎖的占用，直接繼續執行下面的代碼。

EnterUpgradeableReadLock

ReaderWriterLockSlim類提供了可升級讀模式，這種方式和讀模式的區別在于它還有通過調用 EnterWriteLock 或 TryEnterWriteLock 方法升級為寫入模式。 因為每次只能有一個線程處于可升級模式。進入可升級模式的線程，不會影響讀取模式的線程，即當一個線程進入可升級模式，任意數量線程可以同時進入讀取模式，不會阻塞。如果有多個線程已經在等待獲取寫入鎖，那么運行EnterUpgradeableReadLock將會阻塞，直到那些線程超時或者退出寫入鎖。

下面代碼演示了如何在可升級讀模式下，升級到寫入鎖。

1. static public void UpgradeableRead() 
2. { 
3. Console.WriteLine("{0} Thread ID {1} Begin EnterUpgradeableReadLock...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode()); 
4. rwl.EnterUpgradeableReadLock(); 
5. try 
6. { 
7. Console.WriteLine("{0} Thread ID {1} doing sth...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode()); 
8. Console.WriteLine("{0} Thread ID {1} Begin EnterWriteLock...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode()); 
9. rwl.EnterWriteLock(); 
10. try 
11. { 
12. Console.WriteLine("{0} Thread ID {1} writing sth...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode()); 
13. Thread.Sleep(10000);//模擬寫入信息 
14. Console.WriteLine("{0} Thread ID {1} writing end.", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode()); 
15. } 
16. finally 
17. { 
18. rwl.ExitWriteLock(); 
19. Console.WriteLine("{0} Thread ID {1} ExitWriteLock...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode()); 
20. } 
21. Thread.Sleep(10000);//模擬讀取信息 
22. Console.WriteLine("{0} Thread ID {1} doing end.", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode()); 
23. } 
24. finally 
25. { 
26. rwl.ExitUpgradeableReadLock(); 
27. Console.WriteLine("{0} Thread ID {1} ExitUpgradeableReadLock...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode()); 
28. } 
29. } 

讀寫鎖對于性能的影響是明顯的。

下面測試代碼：

1. public class Program 
2. { 
3. static private ReaderWriterLockSlim rwl = new ReaderWriterLockSlim(); 
4. static void Main(string[] args) 
5. { 
6. Stopwatch sw = new Stopwatch(); 
7. sw.Start(); 
8. List<Task> lstTask = new List<Task>(); 
9. for (int i = 0; i < 500; i++) 
10. { 
11. if (i % 25 != 0) 
12. { 
13. var t = Task.Factory.StartNew(ReadSomething); 
14. lstTask.Add(t); 
15. } 
16. else 
17. { 
18. var t = Task.Factory.StartNew(WriteSomething); 
19. lstTask.Add(t); 
20. } 
21. } 
22. Task.WaitAll(lstTask.ToArray()); 
23. sw.Stop(); 
24. Console.WriteLine("使用ReaderWriterLockSlim方式，耗時：" + sw.Elapsed); 
25. sw.Restart(); 
26. lstTask = new List<Task>(); 
27. for (int i = 0; i < 500; i++) 
28. { 
29. if (i % 25 != 0) 
30. { 
31. var t = Task.Factory.StartNew(ReadSomething_lock); 
32. lstTask.Add(t); 
33. } 
34. else 
35. { 
36. var t = Task.Factory.StartNew(WriteSomething_lock); 
37. lstTask.Add(t); 
38. } 
39. } 
40. Task.WaitAll(lstTask.ToArray()); 
41. sw.Stop(); 
42. Console.WriteLine("使用lock方式，耗時：" + sw.Elapsed); 
43. } 
44. static private object _lock1 = new object(); 
45. static public void ReadSomething_lock() 
46. { 
47. lock (_lock1) 
48. { 
49. //Console.WriteLine("{0} Thread ID {1} reading sth...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode()); 
50. Thread.Sleep(10);//模擬讀取信息 
51. //Console.WriteLine("{0} Thread ID {1} reading end.", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode()); 
52. } 
53. } 
54. static public void WriteSomething_lock() 
55. { 
56. lock (_lock1) 
57. { 
58. //Console.WriteLine("{0} Thread ID {1} writing sth...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode()); 
59. Thread.Sleep(100);//模擬寫入信息 
60. //Console.WriteLine("{0} Thread ID {1} writing end.", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode()); 
61. } 
62. } 
63. static public void ReadSomething() 
64. { 
65. rwl.EnterReadLock(); 
66. try 
67. { 
68. //Console.WriteLine("{0} Thread ID {1} reading sth...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode()); 
69. Thread.Sleep(10);//模擬讀取信息 
70. //Console.WriteLine("{0} Thread ID {1} reading end.", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode()); 
71. } 
72. finally 
73. { 
74. rwl.ExitReadLock(); 
75. } 
76. } 
77. static public void WriteSomething() 
78. { 
79. rwl.EnterWriteLock(); 
80. try 
81. { 
82. //Console.WriteLine("{0} Thread ID {1} writing sth...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode()); 
83. Thread.Sleep(100);//模擬寫入信息 
84. //Console.WriteLine("{0} Thread ID {1} writing end.", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode()); 
85. } 
86. finally 
87. { 
88. rwl.ExitWriteLock(); 
89. } 
90. } 
91. } 

上述代碼，就500個Task，每個Task占用一個線程池線程，其中20個寫入線程和480個讀取線程，模擬操作。其中讀取數據花10ms，寫入操作花100ms，分別測試了對于lock方式和ReaderWriterLockSlim方式?？梢宰鲆粋€估算，對于ReaderWriterLockSlim，假設480個線程同時讀取，那么消耗10ms，20個寫入操作占用2000ms，因此所消耗時間2010ms，而對于普通的lock方式，由于都是獨占性的，因此480個讀取操作占時間4800ms+20個寫入操作2000ms=6800ms。運行結果顯示了性能提升明顯。

以上是本文的全部內容，希望對大家熟練應用讀寫鎖ReaderWriterLockSlim有所幫助。