編碼技巧 --- 同步鎖對象的選定

## 引言在C#中，讓線程同步有兩種方式： - 鎖（lock、Monitor） - 信號量（EventWaitHandle、Semaphore、Mutex）線程鎖的原理，就是鎖住一個資源，使得應用程式在此刻只有一個線程訪問該資源。通俗地講，就是讓多線程變成單線程。在C#中，可以將被鎖定的資源理解 ...

引言

在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 變為公開的，是讓調用者自己去決定操作是否需要線程安全。

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