[C# 線程處理系列]專題六：線程同步——信號量和互斥體

也不多說了，直接進入主題了

一、信號量（Semaphore）

信號量（Semaphore）是由內核對象維護的int變量，當信號量為0時，在信號量上等待的線程會堵塞，信號量大於0時，就解除堵塞。當在一個信號量上等待的線程解除堵塞時，內核自動會將信號量的計數減1。在.net 下通過Semaphore類來實現信號量同步。

Semaphore類限制可同時訪問某一資源或資源池的線程數。線程通過調用 WaitOne方法將信號量減1，並通過調用 Release方法把信號量加1。

先說下構造函數：

public Semaphore(int initialCount,int maximumCount);通過兩個參數來設置信號的初始計數和最大計數。

下面通過一段代碼來演示信號量同步的使用：

 

 class Program
    {
        // 初始信號量計數為0，最大計數為10
        public static Semaphore semaphore =new Semaphore(0,10);
        public static int time = 0;
        static void Main(string[] args)
        {
            for (int i = 0; i < 5; i++)
            {
                Thread test = new Thread(new ParameterizedThreadStart(TestMethod));

                // 開始線程，並傳遞參數
                test.Start(i);
            }

            // 等待1秒讓所有線程開始並阻塞在信號量上
            Thread.Sleep(500);

            // 信號量計數加4
            // 最后可以看到輸出結果次數為4次
            semaphore.Release(4);
            Console.Read();         
        }

        public static void TestMethod(object number)
        {
            // 設置一個時間間隔讓輸出有順序
            int span = Interlocked.Add(ref time, 100);
            Thread.Sleep(1000 + span);

            //信號量計數減1
            semaphore.WaitOne();
            
            Console.WriteLine("Thread {0} run ", number);
        }
    }

運行結果：

 

同樣信號量也可以實現進程中線程的同步，同樣也是通過對信號量命名來實現的，

通過調用public Semaphore(int initialCount,int maximumCount,string name);該構造函數多傳入一個信號量名來實現

下面一段實例代碼來演示下：

 

using System;
using System.Threading;

namespace SemaphoreSample
{
    class Program
    {
        // 初始信號量計數為4，最大計數為10
        public static Semaphore semaphore =new Semaphore(4,10,"My");
        public static int time = 0;
        static void Main(string[] args)
        {
            for (int i = 0; i < 3; i++)
            {
                Thread test = new Thread(new ParameterizedThreadStart(TestMethod));

                // 開始線程，並傳遞參數
                test.Start(i);
            }

            // 等待1秒讓所有線程開始並阻塞在信號量上
            Thread.Sleep(1000);

            Console.Read();         
        }

        public static void TestMethod(object number)
        {
            // 設置一個時間間隔讓輸出有順序
            int span = Interlocked.Add(ref time, 500);
            Thread.Sleep(1000 + span);

            //信號量計數減1
            semaphore.WaitOne();
            
            Console.WriteLine("Thread {0} run ", number);
        }
    }
}

運行結果：

從運行結果中可以看出， 第二個進程值運行了一行語句， 因為我們設置的初始信號計數為4，每運行一個線程，信號計數通過調用WaitOne方法減1,所以第二個進行一開始信號計數為1而不是進程一中的4，如果我們把信號計數后面的name參數去除的話，此時第二個進程和第一個進程中的結果應該是一樣的（因為此時沒有進行不同進程中線程的同步）。

 

 

二、互斥體（Mutex）

 

同樣互斥體也是同樣可以實現線程之間的同步和不同進程中線程的同步的

先看看線程之間的同步的例子吧（在這里我也不多做解釋了，因為他們之間的使用很類似，直接貼出代碼）：

 

 class Program
    {
        public static Mutex mutex = new Mutex();
        public static int count;

        static void Main(string[] args)
        {
            for (int i = 0; i < 10; i++)
            {
                Thread test = new Thread(TestMethod);

                // 開始線程，並傳遞參數
                test.Start();
            }

            Console.Read();
        }

        public static void TestMethod()
        {
            mutex.WaitOne();
            Thread.Sleep(500);
            count++;
            Console.WriteLine("Current Cout Number is {0}", count);
            mutex.ReleaseMutex();
        }
    }

運行結果：

 

實現進程間同步：

 

 class Program
    {
        public static Mutex mutex = new Mutex(false,"My");

        static void Main(string[] args)
        {
            Thread t = new Thread(TestMethod);
            t.Start();

            Console.Read();
        }

        public static void TestMethod()
        {
            mutex.WaitOne();
            Thread.Sleep(5000);
            Console.WriteLine("Method start at : " + DateTime.Now.ToLongTimeString());
            mutex.ReleaseMutex();
        }
    }

運行結果：

 

從運行結果看出兩個進程之間的時間間隔為5秒，當我們把構造函數中命名參數去掉時就可以看出差別了。

 

 

到這里多線程處理基本上講完，這個系列也只是一個入門，真真要好好掌握多線程，還是要在項目中多去實戰的。接下來我可能會做一個小的例子的，大概的思路是實現一個文件的下載的這樣的例子。如果大家有什么好的例子來運用多線程的知識的話，可以留言給我，我也會盡量去實現（如果不會的話，這樣也可以促使我去學習），實現后也會和大家分享的。