C#多線程系列之原子操作
知識點
競爭條件
當兩個或兩個以上的線程訪問共享數據,並且嘗試同時改變它時,就發生爭用的情況。它們所依賴的那部分共享數據,叫做競爭條件。
數據爭用是競爭條件中的一種,出現競爭條件可能會導致內存(數據)損壞或者出現不確定性的行為。
線程同步
如果有 N 個線程都會執行某個操作,當一個線程正在執行這個操作時,其它線程都必須依次等待,這就是線程同步。
多線程環境下出現競爭條件,通常是沒有執行正確的同步而導致的。
CPU時間片和上下文切換
時間片(timeslice)是操作系統分配給每個正在運行的進程微觀上的一段 CPU 時間。
首先,內核會給每個進程分配相等的初始時間片,然後每個進程輪番地執行相應的時間,當所有進程都處於時間 片耗盡的狀態時,內核會重新為每個進程計算並分配時間片,如此往復。
請參考:https://zh.wikipedia.org/wiki/%E6%97%B6%E9%97%B4%E7%89%87
上下文切換(Context Switch),也稱做進程切換或任務切換,是指 CPU 從一個進程或線程切換到另一個進程或線程。
在接受到中斷(Interrupt)的時候,CPU 必須要進行上下文交換。進行上下文切換時,會帶來性能損失。
請參考[https://zh.wikipedia.org/wiki/上下文交換
阻塞
阻塞狀態指線程處於等待狀態。當線程處於阻塞狀態時,會盡可能少占用 CPU 時間。
當線程從運行狀態(Runing)變為阻塞狀態時(WaitSleepJoin),操作系統就會將此線程占用的 CPU 時間片分配給別的線程。當線程恢復運行狀態時(Runing),操作系統會重新分配 CPU 時間片。
分配 CPU 時間片時,會出現上下文切換。
內核模式和用戶模式
隻有操作系統才能切換線程、掛起線程,因此阻塞線程是由操作系統處理的,這種方式被稱為內核模式(kernel-mode)。
Sleep()
、Join()
等,都是使用內核模式來阻塞線程,實現線程同步(等待)。
內核模式實現線程等待時,出現上下文切換。這適合等待時間比較長的操作,這樣會減少大量的 CPU 時間損耗。
如果線程隻需要等待非常微小的時間,阻塞線程帶來的上下文切換代價會比較大,這時我們可以使用自旋,來實現線程同步,這一方法稱為用戶模式(user-mode)。
Interlocked 類
為多個線程共享的變量提供原子操作。
使用 Interlocked 類,可以在不阻塞線程(lock、Monitor)的情況下,避免競爭條件。
Interlocked 類是靜態類,讓我們先來看看 Interlocked 的常用方法:
方法 | 作用 |
---|---|
CompareExchange() | 比較兩個數是否相等,如果相等,則替換第一個值。 |
Decrement() | 以原子操作的形式遞減指定變量的值並存儲結果。 |
Exchange() | 以原子操作的形式,設置為指定的值並返回原始值。 |
Increment() | 以原子操作的形式遞增指定變量的值並存儲結果。 |
Add() | 對兩個數進行求和並用和替換第一個整數,上述操作作為一個原子操作完成。 |
Read() | 返回一個以原子操作形式加載的值。 |
全部方法請查看:https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.interlocked?view=netcore-3.1#methods
1,出現問題
問題:
C# 中賦值和一些簡單的數學運算不是原子操作,受多線程環境影響,可能會出現問題。
我們可以使用 lock 和 Monitor 來解決這些問題,但是還有沒有更加簡單的方法呢?
首先我們編寫以下代碼:
private static int sum = 0; public static void AddOne() { for (int i = 0; i < 100_0000; i++) { sum += 1; } }
這個方法的工作完成後,sum 會 +100。
我們在 Main 方法中調用:
static void Main(string[] args) { AddOne(); AddOne(); AddOne(); AddOne(); AddOne(); Console.WriteLine("sum = " + sum); }
結果肯定是 5000000,無可爭議的。
但是這樣會慢一些,如果作死,要多線程同時執行呢?
好的,Main 方法改成如下:
static void Main(string[] args) { for (int i = 0; i < 5; i++) { Thread thread = new Thread(AddOne); thread.Start(); } Thread.Sleep(TimeSpan.FromSeconds(2)); Console.WriteLine("sum = " + sum); }
筆者運行一次,出現瞭 sum = 2633938
我們將每次運算的結果保存到數組中,截取其中一段發現:
8757 8758 8760 8760 8760 8761 8762 8763 8764 8765 8766 8766 8768 8769
多個線程使用同一個變量進行操作時,並不知道此變量已經在其它線程中發生改變,導致執行完畢後結果不符合期望。
我們可以通過下面這張圖來解釋:
因此,這裡就需要原子操作,在某個時刻,必須隻有一個線程能夠進行某個操作。而上面的操作,指的是讀取、計算、寫入這一過程。
當然,我們可以使用 lock 或者 Monitor 來解決,但是這樣會帶來比較大的性能損失。
這時 Interlocked 就起作用瞭,對於一些簡單的操作運算, Interlocked 可以實現原子性的操作。
實現原子性,可以通過多種鎖來解決,目前我們學習到瞭 lock、Monitor,現在來學習 Interlocked ,後面會學到更加多的鎖的實現。
2,Interlocked.Increment()
用於自增操作。
我們修改一下 AddOne 方法:
public static void AddOne() { for (int i = 0; i < 100_0000; i++) { Interlocked.Increment(ref sum); } }
然後運行,你會發現結果 sum = 5000000 ,這就對瞭。
說明 Interlocked 可以對簡單值類型進行原子操作。
Interlocked.Increment() 是遞增,而 Interlocked.Decrement() 是遞減。
3,Interlocked.Exchange()
Interlocked.Exchange()
實現賦值運算。
這個方法有多個重載,我們找其中一個來看看:
public static int Exchange(ref int location1, int value);
意思是將 value 賦給 location1 ,然後返回 location1 改變之前的值。
測試:
static void Main(string[] args) { int a = 1; int b = 5; // a 改變前為1 int result1 = Interlocked.Exchange(ref a, 2); Console.WriteLine($"a新的值 a = {a} | a改變前的值 result1 = {result1}"); Console.WriteLine(); // a 改變前為 2,b 為 5 int result2 = Interlocked.Exchange(ref a, b); Console.WriteLine($"a新的值 a = {a} | b不會變化的 b = {b} | a 之前的值 result2 = {result2}"); }
另外 Exchange()
也有對引用類型的重載:
Exchange<T>(T, T)
4,Interlocked.CompareExchange()
其中一個重載:
public static int CompareExchange (ref int location1, int value, int comparand)
比較兩個 32 位有符號整數是否相等,如果相等,則替換第一個值。
如果 comparand
和 location1
中的值相等,則將 value
存儲在 location1
中。 否則,不會執行任何操作。
看準瞭,是 location1
和 comparand
比較!
使用示例如下:
static void Main(string[] args) { int location1 = 1; int value = 2; int comparand = 3; Console.WriteLine("運行前:"); Console.WriteLine($" location1 = {location1} | value = {value} | comparand = {comparand}"); Console.WriteLine("當 location1 != comparand 時"); int result = Interlocked.CompareExchange(ref location1, value, comparand); Console.WriteLine($" location1 = {location1} | value = {value} | comparand = {comparand} | location1 改變前的值 {result}"); Console.WriteLine("當 location1 == comparand 時"); comparand = 1; result = Interlocked.CompareExchange(ref location1, value, comparand); Console.WriteLine($" location1 = {location1} | value = {value} | comparand = {comparand} | location1 改變前的值 {result}"); }
5,Interlocked.Add()
對兩個 32 位整數進行求和並用和替換第一個整數,上述操作作為一個原子操作完成。
public static int Add (ref int location1, int value);
隻能對 int 或 long 有效。
回到第一小節的多線程求和問題,使用 Interlocked.Add()
來替換Interlocked.Increment()
。
static void Main(string[] args) { for (int i = 0; i < 5; i++) { Thread thread = new Thread(AddOne); thread.Start(); } Thread.Sleep(TimeSpan.FromSeconds(2)); Console.WriteLine("sum = " + sum); } private static int sum = 0; public static void AddOne() { for (int i = 0; i < 100_0000; i++) { Interlocked.Add(ref sum,1); } }
6,Interlocked.Read()
返回一個以原子操作形式加載的 64 位值。
64位系統上不需要 Read 方法,因為64位讀取操作已是原子操作。 在32位系統上,64位讀取操作不是原子操作,除非使用 Read 執行。
public static long Read (ref long location);
就是說 32 位系統上才用得上。
到此這篇關於C#多線程系列之原子操作的文章就介紹到這瞭。希望對大傢的學習有所幫助,也希望大傢多多支持WalkonNet。