細說.NET中的多線程 (五 使用信號量進行同步)

上一節主要介紹了使用鎖進行同步，本節主要介紹使用信號量進行同步

使用EventWaitHandle信號量進行同步

EventWaitHandle主要用於實現信號燈機制。信號燈主要用於通知等待的線程。主要有兩種實現：AutoResetEvent和ManualResetEvent。

AutoResetEvent

AutoResetEvent從字面上理解是一個自動重置的時間。舉個例子，假設有不少人等在門外，AutoResetEvent更像一個十字旋轉門，每一次只容許一我的進入，進入以後門仍然是關閉狀態。

下面的例子演示了使用方式：

using System;
using System.Threading;
class BasicWaitHandle
{
    static EventWaitHandle _waitHandle = new AutoResetEvent(false);

    static void Main()
    {
        for (int i = 0; i < 3; i++)
            new Thread(Waiter).Start();

        for (int i = 0; i < 3; i++)
        {
            Thread.Sleep(1000);                  // Pause for a second...
            Console.WriteLine("通知下一個線程進入");
            _waitHandle.Set();                    // Wake up the Waiter.
        }
        Console.ReadLine();
    }

    static void Waiter()
    {
        var threadId = Thread.CurrentThread.ManagedThreadId;
        Console.WriteLine("線程 {0} 正在等待", threadId);
        _waitHandle.WaitOne();                // 等待通知
        Console.WriteLine("線程 {0} 獲得通知，能夠進入", threadId);
    }
}

　　

雙向信號燈

某些狀況下，若是你連續的屢次使用Set方法通知工做線程，這個時候工做線程可能尚未準備好接收信號，這樣的話後面的幾回Set通知可能會沒有效果。這種狀況下，你須要讓主線程獲得工做線程接收信息的通知再開始發送信息。你可能須要經過兩個信號燈實現這個功能。

示例代碼：

using System;
using System.Threading;
class TwoWaySignaling
{
    static EventWaitHandle _ready = new AutoResetEvent(false);
    static EventWaitHandle _go = new AutoResetEvent(false);
    static readonly object _locker = new object();
    static string _message;

    static void Main()
    {
        new Thread(Work).Start();

        _ready.WaitOne();                  // 在工做線程準備接收信息以前須要一直等待
        lock (_locker) _message = "牀前明月光";
        _go.Set();                         // 通知工做線程開始工做

        _ready.WaitOne();
        lock (_locker) _message = "疑是地上霜";
        _go.Set();
        _ready.WaitOne();
        lock (_locker) _message = "結束";    // 告訴工做線程退出
        _go.Set();

        Console.ReadLine();
    }

    static void Work()
    {
        while (true)
        {
            _ready.Set();                          // 表示當前線程已經準備接收信號
            _go.WaitOne();                         // 工做線程等待通知
            lock (_locker)
            {
                if (_message == "結束") return;        // 優雅的退出~-~
                Console.WriteLine(_message);
            }
        }
    }
}

生產消費隊列

生產消費隊列是多線程編程裏常見的的需求，他的主要思路是：

1. 一個隊列用來存放工做線程須要用到的數據
2. 當新的任務加入隊列的時候，調用線程不須要等待工做結束
3. 1個或多個工做線程在後臺獲取隊列中數據信息

示例代碼：

using System;
using System.Threading;
using System.Collections.Generic;
 
class ProducerConsumerQueue : IDisposable
{
  EventWaitHandle _wh = new AutoResetEvent (false);
  Thread _worker;
  readonly object _locker = new object();
  Queue<string> _tasks = new Queue<string>();
 
  public ProducerConsumerQueue()
  {
    _worker = new Thread (Work);
    _worker.Start();
  }
 
  public void EnqueueTask (string task)
  {
    lock (_locker) _tasks.Enqueue (task);
    _wh.Set();
  }
 
  public void Dispose()
  {
    EnqueueTask (null);     // Signal the consumer to exit.
    _worker.Join();         // Wait for the consumer's thread to finish.
    _wh.Close();            // Release any OS resources.
  }
 
  void Work()
  {
    while (true)
    {
      string task = null;
      lock (_locker)
        if (_tasks.Count > 0)
        {
          task = _tasks.Dequeue();
          if (task == null) return;
        }
      if (task != null)
      {
        Console.WriteLine ("Performing task: " + task);
        Thread.Sleep (1000);  // simulate work...
      }
      else
        _wh.WaitOne();         // No more tasks - wait for a signal
    }
  }
}

爲了保證線程安全，咱們使用lock來保護Queue<string>集合。咱們也顯示的關閉了WaitHandle。

在.NET 4.0中，一個新的類BlockingCollection實現了相似生產者消費者隊列的功能。

ManualResetEvent

ManualResetEvent從字面上看是一個須要手動關閉的事件。舉個例子：假設有不少人等在門外，它像是一個普通的門，門開啓以後，全部等在門外的人均可以進來，當你關閉門以後，再也不容許外面的人進來。

示例代碼：

using System;
using System.Threading;
class BasicWaitHandle
{
    static EventWaitHandle _waitHandle = new ManualResetEvent(false);

    static void Main()
    {
        for (int i = 0; i < 3; i++)
            new Thread(Waiter).Start();


        Thread.Sleep(1000);                  // Pause for a second...
        Console.WriteLine("門已打開，線程進入");
        _waitHandle.Set();                    // Wake up the Waiter.

        new Thread(Waiter).Start();

        Thread.Sleep(2000);

        _waitHandle.Reset();
        Console.WriteLine("門已關閉，線程阻塞");

        new Thread(Waiter).Start();

        Console.ReadLine();
    }

    static void Waiter()
    {
        var threadId = Thread.CurrentThread.ManagedThreadId;
        Console.WriteLine("線程 {0} 正在等待", threadId);
        _waitHandle.WaitOne();                // 等待通知
        Console.WriteLine("線程 {0} 獲得通知，能夠進入", threadId);
    }
}

ManualResetEvent能夠在當前線程喚醒全部等待的線程，這一應用很是重要。

CountdownEvent

CountdownEvent的使用和ManualEvent正好相反，是多個線程共同喚醒一個線程。

示例代碼：

 

using System;
using System.Threading;
class CountDownTest
{
    static CountdownEvent _countdown = new CountdownEvent(3);

    static void Main()
    {
        new Thread(SaySomething).Start("I am thread 1");
        new Thread(SaySomething).Start("I am thread 2");
        new Thread(SaySomething).Start("I am thread 3");

        _countdown.Wait();   // 當前線程被阻塞，直到收到 _countdown發送的三次信號
        Console.WriteLine("All threads have finished speaking!");

        Console.ReadLine();
    }

    static void SaySomething(object thing)
    {
        Thread.Sleep(1000);
        Console.WriteLine(thing);
        _countdown.Signal();
    }
}

建立跨進程的EventWaitHandle

EventWaitHandle的構造方法容許建立一個命名的EventWaitHandle，來實現跨進程的信號量操做。名字只是一個簡單的字符串，只要保證不會跟其它進程的鎖衝突便可。

示例代碼：

EventWaitHandle wh = new EventWaitHandle(false, EventResetMode.AutoReset, "MyCompany.MyApp.SomeName");

　　

若是兩個進程運行這段代碼，信號量會做用於兩個進程內全部的線程。