1、多線程編程必備知識
1.1 進程與線程的概念
當我們打開一個應用程序後，操作系統就會為該應用程序分配一個進程ID，例如打開QQ，你將在任務管理器的進程選項卡看到QQ.exe進程，如下圖：
進程可以理解為一塊包含了某些資源的內存區域，操作系統通過進程這一方式把它的工作劃分為不同的單元。一個應用程序可以對應於多個進程。
線程是進程中的獨立執行單元，對於操作系統而言，它通過調度線程來使應用程序工作，一個進程中至少包含一個線程，我們把該線程成為主線程。線程與進程之間的關系可以理解為：線程是進程的執行單元，操作系統通過調度線程來使應用程序工作；而進程則是線程的容器，它由操作系統創建，又在具體的執行過程中創建了線程。
1.2 線程的調度
在操作系統的書中貌似有提過，“Windows是搶占式多線程操作系統”。之所以這麼說它是搶占式的，是因為線程可以在任意時間裡被搶占，來調度另一個線程。操作系統為每個線程分配了0-31中的某一級優先級，而且會把優先級高的線程優先分配給CPU執行。
Windows支持7個相對線程優先級：Idle、Lowest、BelowNormal、Normal、AboveNormal、Highest和Time-Critical。其中，Normal是默認的線程優先級。程序可以通過設置Thread的Priority屬性來改變線程的優先級，該屬性的類型為ThreadPriority枚舉類型，其成員包括Lowest、BelowNormal、Normal、AboveNormal和Highest。CLR為自己保留了Idle和Time-Critical兩個優先級。
1.3 線程也分前後台
線程有前台線程和後台線程之分。在一個進程中，當所有前台線程停止運行後，CLR會強制結束所有仍在運行的後台線程，這些後台線程被直接終止，卻不會拋出任何異常。主線程將一直是前台線程。我們可以使用Tread類來創建前台線程。
1 using System;
2 using System.Threading;
3
4 namespace 多線程1
5 {
6 internal class Program
7 {
8 private static void Main(string[] args)
9 {
10 var backThread = new Thread(Worker);
11 backThread.IsBackground = true;
12 backThread.Start();
13 Console.WriteLine("從主線程退出");
14 Console.ReadKey();
15 }
16
17 private static void Worker()
18 {
19 Thread.Sleep(1000);
20 Console.WriteLine("從後台線程退出");
21 }
22 }
23 }
以上代碼先通過Thread類創建了一個線程對象，然後通過設置IsBackground屬性來指明該線程為後台線程。如果不設置這個屬性，則默認為前台線程。接著調用了Start的方法，此時後台線程會執行Worker函數的代碼。所以在這個程序中有兩個線程，一個是運行Main函數的主線程，一個是運行Worker線程的後台線程。由於前台線程執行完畢後CLR會無條件地終止後台線程的運行，所以在前面的代碼中，若啟動了後台線程，則主線程將會繼續運行。主線程執行完後，CLR發現主線程結束，會終止後台線程，然後使整個應用程序結束運行，所以Worker函數中的Console語句將不會執行。所以上面代碼的結果是不會運行Worker函數中的Console語句的。
可以使用Join函數的方法，確保主線程會在後台線程執行結束後才開始運行。
1 using System;
2 using System.Threading;
3
4 namespace 多線程1
5 {
6 internal class Program
7 {
8 private static void Main(string[] args)
9 {
10 var backThread = new Thread(Worker);
11 backThread.IsBackground = true;
12 backThread.Start();
13 backThread.Join();
14 Console.WriteLine("從主線程退出");
15 Console.ReadKey();
16 }
17
18 private static void Worker()
19 {
20 Thread.Sleep(1000);
21 Console.WriteLine("從後台線程退出");
22 }
23 }
24 }
以上代碼調用Join函數來確保主線程會在後台線程結束後再運行。
如果你線程執行的方法需要參數，則就需要使用new Thread的重載構造函數Thread(ParameterizedThreadStart).
1 using System;
2 using System.Threading;
3
4 namespace 多線程1
5 {
6 internal class Program
7 {
8 private static void Main(string[] args)
9 {
10 var backThread = new Thread(new ParameterizedThreadStart(Worker));
11 backThread.IsBackground = true;
12 backThread.Start("Helius");
13 backThread.Join();
14 Console.WriteLine("從主線程退出");
15 Console.ReadKey();
16 }
17
18 private static void Worker(object data)
19 {
20 Thread.Sleep(1000);
21 Console.WriteLine($"傳入的參數為{data.ToString()}");
22 }
23 }
24 }
執行結果為：
2、線程的容器——線程池
前面我們都是通過Thead類來手動創建線程的，然而線程的創建和銷毀會耗費大量時間，這樣的手動操作將造成性能損失。因此，為了避免因通過Thread手動創建線程而造成的損失，.NET引入了線程池機制。
2.1 線程池
線程池是指用來存放應用程序中要使用的線程集合，可以將它理解為一個存放線程的地方，這種集中存放的方式有利於對線程進行管理。
CLR初始化時，線程池中是沒有線程的。在內部，線程池維護了一個操作請求隊列，當應用程序想要執行一個異步操作時，需要調用QueueUserWorkItem方法來將對應的任務添加到線程池的請求隊列中。線程池實現的代碼會從隊列中提取，並將其委派給線程池中的線程去執行。如果線程池沒有空閒的線程，則線程池也會創建一個新線程去執行提取的任務。而當線程池線程完成某個任務時，線程不會被銷毀，而是返回到線程池中，等待響應另一個請求。由於線程不會被銷毀，所以也就避免了性能損失。記住，線程池裡的線程都是後台線程，默認級別是Normal。
2.2 通過線程池來實現多線程
要使用線程池的線程，需要調用靜態方法ThreadPool.QueueUserWorkItem，以指定線程要調用的方法，該靜態方法有兩個重載版本：
public static bool QueueUserWorkItem(WaitCallback callBack);
public static bool QueueUserWorkItem(WaitCallback callback,Object state)
這兩個方法用於向線程池隊列添加一個工作先以及一個可選的狀態數據。然後，這兩個方法就會立即返回。下面通過實例來演示如何使用線程池來實現多線程編程。
1 using System;
2 using System.Threading;
3
4 namespace 多線程2
5 {
6 class Program
7 {
8 static void Main(string[] args)
9 {
10 Console.WriteLine($"主線程ID={Thread.CurrentThread.ManagedThreadId}");
11 ThreadPool.QueueUserWorkItem(CallBackWorkItem);
12 ThreadPool.QueueUserWorkItem(CallBackWorkItem,"work");
13 Thread.Sleep(3000);
14 Console.WriteLine("主線程退出");
15 Console.ReadKey();
16 }
17
18 private static void CallBackWorkItem(object state)
19 {
20 Console.WriteLine("線程池線程開始執行");
21 if (state != null)
22 {
23 Console.WriteLine($"線程池線程ID={Thread.CurrentThread.ManagedThreadId},傳入的參數為{state.ToString()}");
24 }
25 else
26 {
27 Console.WriteLine($"線程池線程ID={Thread.CurrentThread.ManagedThreadId}");
28 }
29 }
30 }
31 }
結果為：
2.3 協作式取消線程池線程
.NET Framework提供了取消操作的模式，這個模式是協作式的。為了取消一個操作，必須創建一個System.Threading.CancellationTokenSource對象。下面還是使用代碼來演示一下：
using System;
using System.Threading;
namespace 多線程3
{
internal class Program
{
private static void Main(string[] args)
{
Console.WriteLine("主線程運行");
var cts = new CancellationTokenSource();
ThreadPool.QueueUserWorkItem(Callback, cts.Token);
Console.WriteLine("按下回車鍵來取消操作");
Console.Read();
cts.Cancel();
Console.ReadKey();
}
private static void Callback(object state)
{
var token = (CancellationToken) state;
Console.WriteLine("開始計數");
Count(token, 1000);
}
private static void Count(CancellationToken token, int count)
{
for (var i = 0; i < count; i++)
{
if (token.IsCancellationRequested)
{
Console.WriteLine("計數取消");
return;
}
Console.WriteLine($"計數為：{i}");
Thread.Sleep(300);
}
Console.WriteLine("計數完成");
}
}
}
結果為：
3、線程同步
線程同步計數是指多線程程序中，為了保證後者線程，只有等待前者線程完成之後才能繼續執行。這就好比生活中排隊買票，在前面的人沒買到票之前，後面的人必須等待。
3.1 多線程程序中存在的隱患
多線程可能同時去訪問一個共享資源，這將損壞資源中所保存的數據。這種情況下，只能采用線程同步技術。
3.2 使用監視器對象實現線程同步
監視器對象（Monitor）能夠確保線程擁有對共享資源的互斥訪問權，C#通過lock關鍵字來提供簡化的語法。
1 using System;
2 using System.Collections.Generic;
3 using System.Linq;
4 using System.Text;
5 using System.Threading;
6 using System.Threading.Tasks;
7
8 namespace 線程同步
9 {
10 class Program
11 {
12 private static int tickets = 100;
13 static object globalObj=new object();
14 static void Main(string[] args)
15 {
16 Thread thread1=new Thread(SaleTicketThread1);
17 Thread thread2=new Thread(SaleTicketThread2);
18 thread1.Start();
19 thread2.Start();
20 Console.ReadKey();
21 }
22
23 private static void SaleTicketThread2()
24 {
25 while (true)
26 {
27 try
28 {
29 Monitor.Enter(globalObj);
30 Thread.Sleep(1);
31 if (tickets > 0)
32 {
33 Console.WriteLine($"線程2出票：{tickets--}");
34 }
35 else
36 {
37 break;
38 }
39 }
40 catch (Exception)
41 {
42 throw;
43 }
44 finally
45 {
46 Monitor.Exit(globalObj);
47 }
48 }
49 }
50
51 private static void SaleTicketThread1()
52 {
53 while (true)
54 {
55 try
56 {
57 Monitor.Enter(globalObj);
58 Thread.Sleep(1);
59 if (tickets > 0)
60 {
61 Console.WriteLine($"線程1出票：{tickets--}");
62 }
63 else
64 {
65 break;
66 }
67 }
68 catch (Exception)
69 {
70 throw;
71 }
72 finally
73 {
74 Monitor.Exit(globalObj);
75 }
76 }
77 }
78 }
79 }
在以上代碼中，首先額外定義了一個靜態全局變量globalObj，並將其作為參數傳遞給Enter方法。使用了Monitor鎖定的對象需要為引用類型，而不能為值類型。因為在將值類型傳遞給Enter時，它將被先裝箱為一個單獨的毒香，之後再傳遞給Enter方法；而在將變量傳遞給Exit方法時，也會創建一個單獨的引用對象。此時，傳遞給Enter方法的對象和傳遞給Exit方法的對象不同，Monitor將會引發SynchronizationLockException異常。
3.3 線程同步技術存在的問題
（1）使用比較繁瑣。要用額外的代碼把多個線程同時訪問的數據包圍起來，還並不能遺漏。
（2）使用線程同步會影響程序性能。因為獲取和釋放同步鎖是需要時間的；並且決定那個線程先獲得鎖的時候，CPU也要進行協調。這些額外的工作都會對性能造成影響。
（3）線程同步每次只允許一個線程訪問資源，這會導致線程堵塞。繼而系統會創建更多的線程，CPU也就要負擔更繁重的調度工作。這個過程會對性能造成影響。
下面就由代碼來解釋一下性能的差距：
1 using System;
2 using System.Collections.Generic;
3 using System.Diagnostics;
4 using System.Linq;
5 using System.Text;
6 using System.Threading;
7 using System.Threading.Tasks;
8
9 namespace 線程同步2
10 {
11 class Program
12 {
13 static void Main(string[] args)
14 {
15 int x = 0;
16 const int iterationNumber = 5000000;
17 Stopwatch stopwatch=Stopwatch.StartNew();
18 for (int i = 0; i < iterationNumber; i++)
19 {
20 x++;
21 }
22 Console.WriteLine($"不使用鎖的情況下花費的時間:{stopwatch.ElapsedMilliseconds}ms");
23 stopwatch.Restart();
24 for (int i = 0; i < iterationNumber; i++)
25 {
26 Interlocked.Increment(ref x);
27 }
28 Console.WriteLine($"使用鎖的情況下花費的時間:{stopwatch.ElapsedMilliseconds}ms");
29 Console.ReadKey();
30 }
31 }
32 }
執行結果：
實踐出結論。
