編碼技巧 --- 同步鎖物件的選定

引言

在C#中，讓執行緒同步有兩種方式：

鎖（lock、Monitor）
號誌（EventWaitHandle、Semaphore、Mutex）

執行緒鎖的原理，就是鎖住一個資源，使得應用程式在此刻只有一個執行緒存取該資源。通俗地講，就是讓多執行緒變成單執行緒。在C#中，可以將被鎖定的資源理解成 new 出來的普通CLR物件。

如何選定

既然需要鎖定的資源就是C#中的一個物件，我們就該仔細思考，到底什麼樣的物件能夠成為一個鎖物件（也叫同步物件）？

那麼選擇同步物件的時候，應當始終注意以下幾點：

同步物件在需要同步的多個執行緒中是可見的同一個物件。
在非靜態方法中，靜態變數不應作為同步物件。
值型別物件不能作為同步物件。
避免將字串作為同步物件。
降低同步物件的可見性。

原因分析

接下來就探討一下這五種情況。

注意事項1：需要鎖定的物件在多個執行緒中是可見的，而且是同一個物件。

「可見的」這是顯而易見的，如果物件不可見，就不能被鎖定。

「同一個物件」，這也很容易理解，如果鎖定的不是同一個物件，那又如何來同步兩個物件呢？

雖然理解起來簡單，但不見得我們在這上面就不會犯錯誤。

我們模擬一個必須使用到鎖的場景：在遍歷一個集合的過程中，同時在另外一個執行緒中刪除集合中的某項。

下面這個例子中，如果沒有 lock 語句，將會丟擲異常System.InvalidOperationException:「Collection was modified; enumeration operation may not execute.」

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }

    AutoResetEvent autoResetEvent = new AutoRe

    List<string> strings = new List<string>() 

    private void btn_StartThreads_Click(object
    {
        object syncObj = new object();

        Thread t1 = new Thread(() =>
        {
            //確保等待t2開始之後才執行下面的程式碼
            autoResetEvent.WaitOne();

            lock (syncObj)
            {
                foreach (var item in strings)
                {
                    Thread.Sleep(1000);
                }
            }
        });
        t1.IsBackground = false;

        t1.Start();

        Thread t2 = new Thread(() =>
        {
            autoResetEvent.Set();

            Thread.Sleep(1000);

            lock (syncObj)
            {
                strings.RemoveAt(1);
            }

        });
        t2.IsBackground = false;

        t2.Start();
    }
}

上述例子是 Winform 表單應用程式，按鈕的單擊事件中演示該功能。物件 syncObj 對於執行緒 t1 和 t2 來說，在CLR中肯定是同一個物件。所以，上面的範例執行是沒有問題的。

現在，我們將此範例重構。將實際的工作程式碼移到一個型別 SampleClass 中，該範例要在多個 SampleClass 範例間操作一個靜態欄位，如下所示：

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }

    private void btn_StartThreads_Click(object sender, EventArgs e)
    {
        SampleClass sampleClass1 = new SampleClass();
        SampleClass sampleClass2 = new SampleClass();
        sampleClass1.StartT1();
        sampleClass2.StartT2();
    }
}

public class SampleClass
{
    public static AutoResetEvent autoResetEvent = new AutoResetEvent(false);

    static List<string> strings = new List<string>() { "str1", "str2", "str3" };

    object syncObj = new object();

    public void StartT1()
    {
        Thread t1 = new Thread(() =>
        {
            //確保等待t2開始之後才執行下面的程式碼
            autoResetEvent.WaitOne();

            lock (syncObj)
            {
                foreach (var item in strings)
                {
                    Thread.Sleep(1000);
                }
            }
        });
        t1.IsBackground = false;

        t1.Start();
    }
    public void StartT2()
    {
        Thread t2 = new Thread(() =>
        {
            autoResetEvent.Set();

            Thread.Sleep(1000);

            lock (syncObj)
            {
                strings.RemoveAt(1);
            }

        });
        t2.IsBackground = false;

        t2.Start();
    }
}

該例子執行起來就會丟擲異常System.InvalidOperationException:「Collection was modified; enumeration operation may not execute.」

檢視型別 SampleClass 的方法 StartT1 和 StartT2 ,方法內部鎖定的是 SampleClass 的範例變數 syncObj 。

範例變數意味著，每建立一個 SampleClass 的範例都會生成一個 syncObj 物件。

在本例中，呼叫者一共建立了兩個 SampleClass 範例，繼而分別呼叫：

samplel.StartTl();
sample2.StartT2();

也就是說，以上程式碼鎖定的是兩個不同的 syncObj ，這等於完全沒有達到兩個執行緒鎖定同一個物件的目的。

要修正以上錯誤，只要將 syncObj 變成 static 就可以了。

另外，思考一下 lock(this) ，我們同樣不建議在程式碼中編寫這樣的程式碼。如果兩個物件的範例分別執行了鎖定的程式碼，實際鎖定的也就會是兩個物件，完全不能達到同步的目的。

第二個注意事項：在非靜態方法中，靜態變數不應作為同步物件。

上文說到，要修正第一個注意事項中的範例問題，需要將 syncObj 變成 static。這似乎和本注意事項有矛盾。事實上，第一個注意事項中的範例程式碼僅僅出於演示的目的，在實際應用中，我們非常不建議編寫此類程式碼。

在編寫多執行緒程式碼時，要遵循這樣的一個原則：

型別的靜態方法應當保證執行緒安全，非靜態方法不需實現執行緒安全。

FCL中的絕大部分類都遵循了這個原則。

像上一個範例中，如果將 syncObj 變成 static，就相當於讓非靜態方法具備了執行緒安全性，這帶來的一個問題是，如果應用程式中該型別存在多個範例，在遇到這個鎖的時候，它們都會產生同步，而這可能不是開發者所願意看到的。第二個注意事項實際也可以歸納到第一個注意事項中。

第三個注意事項：值型別物件不能作為同步物件。

值型別在傳遞到另一個執行緒的時候，會建立一個副本，這相當於每個執行緒鎖定的也是兩個物件。因此，值型別物件不能作為同步物件。
第四個注意事項：鎖定字串是完全沒有必要的，而且相當危險。

這整個過程看上去和值型別正好相反。字串在CLR中會被暫存到記憶體裡，如果有兩個變數被分配了相同內容的字串，那麼這兩個參照會被指向同一塊記憶體。所以，如果有兩個地方同時使用了lock(「abc」) ，那麼它們實際鎖定的是同一個物件，這會導致整個應用程式被阻滯。

第五個注意事項：降低同步物件的可見性。

可見範圍最廣的一種同步物件是 typeof(SampleClass)。

typeof()方法所返回的結果（也就是型別的type)是SampleClass 的所有範例所共有的，即：所有範例的type都指向typeof方法的結果。

這樣一來，如果我們 lock(typeof(SampleClass) ,當前應用程式中所有 SampleClass 的範例執行緒將會全部被同步。這樣編碼完全沒有必要，而且這樣的同步物件太開放了。

一般來說，同步物件也不應該是一個公共變數或屬性。在FCL的早期版本中，一些常用的集合型別（如 ArrayList )提供了公共屬性 SyncRoot ，讓我們鎖定以便進行一些執行緒安全的操作。

所以你一定會覺得我們剛才的結論不正確。其實不然，ArrayList 操作的大部分應用場景不涉及多執行緒同步，所以它的方法更多的是單執行緒應用場景。執行緒同步是一個非常耗時（低效）的操作。若 ArrayList 的所有非靜態方法都要考慮執行緒安全，那麼 ArrayList 完全可以將這個 SyncRoot 變成靜態私有的。現在它將 SyncRoot 變為公開的，是讓呼叫者自己去決定操作是否需要執行緒安全。

我們在編寫程式碼時，除非有這樣的要求，否則就應該始終考慮降低同步物件的可見性，將同步物件藏起來，只開放給自己或自己的子類就夠了（需要開放給子類的情況其實也不多）。

本篇內容參照自

編寫高質量程式碼：改善C#程式的157個建議 / 陸敏技著.一北京：機械工業出版社，2011.9