.net中線程同步的典型場景和問題(1)

在使用多線程進行編程時，有一些經典的線程同步問題，對於這些問題，.net提供了多種不同的類來解決。除了要考慮場景本身，一個重要的問題是，這些線程是否在同一個應用程序域中運行。如果線程都在同一應用程序域中運行，則可以使用一些所謂“輕量”級的同步類，否則要使用另一些類，而這些類都是對操作系統所提供的同步原語的包裝，相對來說更消耗資源。我在這兒介紹一些典型的應用場景和相關的問題。

目錄

多線程爭用獨占資源

常常有一些資源線程獨占的，如果有多個線程同時需要訪問這要的資源，就形成了一個爭用問題。這類資源有“文件”，“打印機”，“串口”，以及所有非線程安全的類對象（絕大部分類庫中的類都是）。典型的代碼：

    var objLock = new Object();
    var thread1 = new Thread(() =>
    {
        lock (objLock)
        {
            AccessResource();
        }

    });
    var thread2 = new Thread(() =>
    {
        lock (objLock)
        {
            AccessResource();
        }

    });

上面代碼中，lock關鍵字實際上Monitor類的一個語法糖。任意一個對象(非值類型)上都有一個鎖區域，Monitor.Enter方法會嘗試鎖定該區域，如果鎖定成功，線程就擁有該對象，反子，線程將被掛起。對於objLock對象，有以下點需要注意:

• 不要鎖定this
• 不要鎖定Type
• 不要鎖定字符串
• 不要鎖定值類型的對象

對於相同的類，通常都會有很多不同的實例，這樣的話，有可能會鎖定到多個不同的對象上，從而使鎖失效。不要鎖定Type的原因有兩點，一是生成Type類對象相對比較慢比較占資源，二是Type類型通常是公共的，這樣有可能會在程序的多個不同地方會鎖定，這實際上是個工程問題，主要是為了防止引入BUG。不要鎖定string類，是因數，所有字面值相同的字符串，實際上是共享同一個對象的，所以和Type一樣，也可能會無意間被別的代碼鎖定，這樣的Bug將難以排除。不要鎖定值類型，因為值類型本身是不可鎖定的，為了可以鎖定，編譯器值將它裝箱,而每次裝箱實際上都會生成一個不同的對象實例，這樣鎖定也就沒有任何效果了。

上面的代碼有效的原因是所有線程都在同一個應用程序中，也就是不涉及進程間的資源爭用。如果是多進程間的資源爭用，可以使用Mutex類。Mutex類有兩種不同用法，匿名互斥體和命名互斥體，命名的互斥體是在整個操作系統范圍內共用的，所以可以用於進程間同步。

 

    var mutex = new Mutex(false, "name");
    var thread1 = new Thread(() =>
    {
        try
        {
            mutex.WaitOne();
            AccessResource();
        }
        finally
        {
            mutex.ReleaseMutex();
        }

    });
    var thread2 = new Thread(() =>
    {
        try
        {
            mutex.WaitOne();
            AccessResource();
        }
        finally
        {
            mutex.ReleaseMutex();
        }
    });

需要注意的是，在線程結束時,必須釋放互斥體。

一對一的生產者/消費者模型

在這種模型中，有一個生產者線程在產生需要處理的數據，同時有一個消費者線程在處理數據，通常來說，數據存放在一個緩存中。在種情況下，生產者每產生一個數據，就將它放入緩存中，並設置信號量(WaitHandle)，以通知消費者線程去處理。消費者不斷的處理數據，如果發現所有數據都已經處理完畢，則進入阻塞狀態，以等待生產者線程產生數據。信號量有兩種，一種是AutoResetEvent,另一種是ManualResetEvent。前者的特點是每次設置一個信號后，將喚醒一個阻塞的線程，然后馬上將信號量未設置狀態。而后者的狀態，則完全由程序控制，可能一次喚醒多個線程，也可能未喚醒作何一個線程。這種模型的例子代碼。

using System;
using System.Collections.Generic;
using System.Threading;

namespace ThreadCancle
{
    public class ProducerConsumer2
    {
        public static void Main()
        {
            var autoResetEvent = new AutoResetEvent(false);
            var queue = new Queue<int>();
            var producterThread = new Thread(() =>
            {
                var rand = new Random();
                while (true)
                {
                    var value = rand.Next(100);
                    lock (queue)
                    {
                        queue.Enqueue(value);
                    }
                    Thread.Sleep(rand.Next(400, 1200));
                    Console.WriteLine("產生了數據{0}。", value);
                    autoResetEvent.Set();
                }
            });
            var consumerThread = new Thread(() =>
            {
                while (true)
                {
                    autoResetEvent.WaitOne();
                    int value = 0;
                    bool hasValue = true;
                    while (hasValue)
                    {
                        lock (queue)
                        {
                            hasValue = (queue.Count > 0);
                            if (hasValue)
                            {
                                value = queue.Dequeue();
                            }
                        }
                        Thread.Sleep(800);
                        Console.WriteLine("處理了數據{0}。", value);
                    }
                }
            });

            producterThread.Start();
            consumerThread.Start();
            Console.ReadLine();
        }
    }
}

在上面的例子中，生產者間隔0.4-1.2秒產生一個需要處理的數據，而消費者的處理能力是每0.8秒處理一個數據。生產者不斷的產生數據，並將它放入queue中，然后喚醒消費者線程。消費者線程將queue中所有的數據處理完成后進入阻塞狀態。需要注意的是,消費者線程和生產者線程會同時對queue對象進行訪問，所有每次訪問它們的時候必須鎖定。執行鎖定的時候必須遵循最少占用時間原則，一旦使用完畢應當立即釋放鎖定。