[分享] C# 小技巧系列 - Multithreading

[[ 入門 ]]

C# 透過 Multithreading（多線程）來支援 parallel execution，
thread是個獨立的執行路徑，能夠跟其它thread一起跑。

當一個C#程式開始時，作業系統和CLR會自動為它建立一個thread，即 main thread，
例如：

///
using System;
using System.Threading;

class MainClass {
	static void Main() {
		while (true) Console.Write("M");
	}
}
///

這個 main thread 不斷顯示 "M" 字元。
（可以按Pause來暫停，按Ctrl-C中斷）

透過由 main thread 去建立一些 thread，就能夠變成 multithreading：

///
using System;
using System.Threading;

class MainClass {
	static void Main() {
		Thread ta = new Thread( new ThreadStart(WriteA) );
		ta.Start();

		Thread tb = new Thread( new ThreadStart(WriteB) );
		tb.Start();
		
		while (true) Console.Write("M");
	}
	static void WriteA() {
		while (true) Console.Write("A");
	}
	static void WriteB() {
		while (true) Console.Write("B");
	}
}	
///

結果三個 thread 在一起跑。

（稍後介紹ThreadStart）

您可以為每個thread設定Name屬性，這樣會方便偵錯，
Visual Studio會在 Threads視窗顯示它們的 Name：

///
using System;
using System.Threading;

class MainClass {
	static void Main() {
		Thread ta = new Thread( new ThreadStart(Write) );
		ta.Name = "A";
		ta.Start();

		Thread tb = new Thread( new ThreadStart(Write) );
		tb.Name = "B";
		tb.Start();
		
		Thread t = Thread.CurrentThread;
		t.Name = "M";
		Write();
	}
	static void Write() {
		Thread t = Thread.CurrentThread;
		while (true) Console.Write( t.Name );
	}
}	
///

A, B 和 M都會跑到 Write的主體內，
您可以用 Thread.CurrentThread 表示當前在跑的 thread。


每個thread都有自已的 memory stack，這是由CLR賦予的，
所以每個thread都有自己的本域變數，不會被其它thread影響變數內容，例如：

///
using System;
using System.Threading;

class MainClass {
	static void Main() {
		Thread ta = new Thread( new ThreadStart(Write) );
		ta.Name = "A";
		ta.Start();

		Thread tb = new Thread( new ThreadStart(Write) );
		tb.Name = "B";
		tb.Start();
		
		Thread t = Thread.CurrentThread;
		t.Name = "M";
		Write();
	}
	static void Write() {
		Thread t = Thread.CurrentThread;

		for (int i = 1; i <= 10; i++) {  
			Console.Write( t.Name );
		}
	}
}	
///

結果每個 thread 都顯示 10 個字元，
在 Write 內有本域變數 i 和 t，每個thread的 i 和 t 都不受其它 thread影響。


本域變數不會共用，而 field (static 或 instance) 就可以。
以下建立 Person 類，它有一個 instance field 叫 m_Married。

我們要求只有當 m_Married是 false 的時候，才去把它設成 true，
否則不要去設它。

///
using System;
using System.Threading;

public class Person {
	private bool m_Married = false;

	public void Go() {
		Thread t = Thread.CurrentThread;
		
		if (! m_Married) {
			m_Married = true;

			Console.WriteLine("changed: " + t.Name);
		} else {
			Console.WriteLine("no changed: " + t.Name);
		}
	}
}

class MainClass {
	static void Main() {
		Person p = new Person();
		
		Thread ta = new Thread( new ThreadStart(p.Go) );
		ta.Name = "A";
		ta.Start();

		Thread t = Thread.CurrentThread;
		t.Name = "M";
		p.Go();
	}
}	
///

執行結果：
changed: M
no changed: A


因為A 和 M 都是透過 p 來呼叫 Go，所以它們會共用這個物件的 m_Married，
M設了m_Married，A也可以檢查得到。

當您觀察執行結果後，會發現當其中一個thread 把 m_Married設成 true，
另一個就不會再設，符合我們的要求。
不過，事實並非真的如此。

試試在 if 敍述加入 Thread.Sleep(1000); ，
讓當前的 thread 睡眠一秒，然後繼續跑。

		if (! m_Married) {
			Thread.Sleep(1000);
			m_Married = true;

			Console.WriteLine("changed: " + t.Name);
		} else {
			Console.WriteLine("no changed: " + t.Name);
		}


會出現類似這樣的結果：
changed: M
changed: A

結果 M 和 A 都會把 m_Married 設成 true。

問：為什麼之前的執行結果沒有問題呢？
答：沒有發現問題，並不代表沒有問題。

只是，它可能在一萬次執行中才會出現一次問題，
但是，如果每個星期會執行一萬次，就可以預計每星期會出現一次問題。

考慮以下執行順序，就會發現問題原因：

1) m_Married = false;
2) M 執行 if (! m_Married)，條件成立
3) A 執行 if (! m_Married)，條件成立
4) M 執行 m_Married = true;
5) A 執行 m_Married = true;


解決這個問題，其中一個辦法是用 lock：

	public void Go() {
		Thread t = Thread.CurrentThread;
		
		Console.WriteLine("before enter: " + t.Name);
		lock (this) {
			Console.WriteLine("after enter: " + t.Name);
			if (! m_Married) {
				Thread.Sleep(1000);
				m_Married = true;
	
				Console.WriteLine("changed: " + t.Name);
			} else {
				Console.WriteLine("no changed: " + t.Name);
			}
			Console.WriteLine("before exit: " + t.Name);
		}
		Console.WriteLine("after exit: " + t.Name);
	}


lock 的語法是：
lock(expression) statement_block

當某個thread執行到lock 這句，就會嘗試為物件取得mutual-exclusion lock，
如果取到的話，就執行 statement_block，執行後釋放這個 lock。
如果取不到lock，就會等待，直至取到為止。

所以，它的效果是只有取到lock 的thread才能進入 statement_block
（該範圍被標為critical section），
即同時間不可能有超過一個thread入到critical section。