C# 多線程學習總結

C#多線程學習(一) 多線程的相關概念

什么是進程？

      當一個程序開始運行時，它就是一個進程，進程包括運行中的程序和程序所使用到的內存和系統資源。而一個進程又是由多個線程所組成的。

什么是線程？

      線程是程序中的一個執行流，每個線程都有自己的專有寄存器(棧指針、程序計數器等)，但代碼區是共享的，即不同的線程可以執行同樣的函數。

什么是多線程？

     多線程是指程序中包含多個執行流，即在一個程序中可以同時運行多個不同的線程來執行不同的任務，也就是說允許單個程序創建多個並行執行的線程來完成各自的任務。

多線程的好處：

      可以提高CPU的利用率。在多線程程序中，一個線程必須等待的時候，CPU可以運行其它的線程而不是等待，這樣就大大提高了程序的效率。

多線程的不利方面：

     線程也是程序，所以線程需要占用內存，線程越多占用內存也越多； 多線程需要協調和管理，所以需要CPU時間跟蹤線程； 線程之間對共享資源的訪問會相互影響，必須解決競用共享資源的問題；線程太多會導致控制太復雜，最終可能造成很多Bug；

     接下來將對C#編程中的多線程機制進行探討。為了省去創建GUI那些繁瑣的步驟，更清晰地逼近線程的本質，接下來的所有程序都是控制台程序，程序最后的Console.ReadLine()是為了使程序中途停下來，以便看清楚執行過程中的輸出。

任何程序在執行時，至少有一個主線程。

一個直觀印象的線程示例：   

using System;
using System.Threading;
namespace ThreadTest
{
class RunIt
{
[STAThread]
static void Main(string[] args)
{
//給當前線程起名為"System Thread"
Thread.CurrentThread.Name="System Thread";
Console.WriteLine(Thread.CurrentThread.Name+"'Status:"+
Thread.CurrentThread.ThreadState);
Console.ReadLine();
}
}
}

輸出如下：

System Thread's Status:Running

     在這里，我們通過Thread類的靜態屬性CurrentThread獲取了當前執行的線程，對其Name屬性賦值“System Thread”，最后還輸出了它的當前狀態（ThreadState）。

      所謂靜態屬性，就是這個類所有對象所公有的屬性，不管你創建了多少個這個類的實例，但是類的靜態屬性在內存中只有一個。很容易理解CurrentThread為什么是靜態的——雖然有多個線程同時存在，但是在某一個時刻，CPU只能執行其中一個。

在程序的頭部，我們使用了如下命名空間：

using System;

using System.Threading;

      在.net framework class library中，所有與多線程機制應用相關的類都是放在System.Threading命名空間中的。如果你想在你的應用程序中使用多線程，就必須包含這個類。

      我們通過其中提供的Thread類來創建和控制線程，ThreadPool類用於管理線程池等。（此外還提供解決了線程執行安排，死鎖，線程間通訊等實際問題的機制。）

Thread類有幾個至關重要的方法，描述如下：

Start()：啟動線程；

Sleep(int)：靜態方法，暫停當前線程指定的毫秒數；

Abort()：通常使用該方法來終止一個線程；

Suspend()：該方法並不終止未完成的線程，它僅僅掛起線程，以后還可恢復；

Resume()：恢復被Suspend()方法掛起的線程的執行。

C#多線程學習(二) 如何操縱一個線程

     下面我們就動手來創建一個線程，使用Thread類創建線程時，只需提供線程入口即可。（線程入口使程序知道該讓這個線程干什么事）

     在C#中，線程入口是通過ThreadStart代理（delegate）來提供的，你可以把ThreadStart理解為一個函數指針，指向線程要執行的函數，當調用Thread.Start()方法后，線程就開始執行ThreadStart所代表或者說指向的函數。

      打開你的VS.net，新建一個控制台應用程序（Console Application），編寫完全控制一個線程的代碼示例：

using System;
using System.Threading; 

namespace ThreadTest
{
    public class Alpha
    {
        public void Beta()
        {
            while (true)
            {
                Console.WriteLine("Alpha.Beta is running in its own thread.");
            }
        }
    }; 

public class Simple
{
    public static int Main()
    {
　         Console.WriteLine("Thread Start/Stop/Join Sample");
            Alpha oAlpha = new Alpha();
　　      file://這里創建一個線程，使之執行Alpha類的Beta()方法
　　      Thread oThread = new Thread(new ThreadStart(oAlpha.Beta));
　　      oThread.Start();
　　      while (!oThread.IsAlive)
　　            Thread.Sleep(1);
　　            oThread.Abort();
　　            oThread.Join();
　　            Console.WriteLine();
　　            Console.WriteLine("Alpha.Beta has finished"); 
　　            try 
　　            {
　　　　            Console.WriteLine("Try to restart the Alpha.Beta thread");
　　　　            oThread.Start();
　　            }
　　            catch (ThreadStateException) 
　　            {
　　　　           Console.Write("ThreadStateException trying to restart Alpha.Beta. ");
　　　　           Console.WriteLine("Expected since aborted threads cannot be restarted.");
　　　　           Console.ReadLine();
　　            }
　　          return 0;
　　  }
    }
}

      這段程序包含兩個類Alpha和Simple，在創建線程oThread時我們用指向Alpha.Beta()方法的初始化了ThreadStart代理（delegate）對象，當我們創建的線程oThread調用oThread.Start()方法啟動時，實際上程序運行的是Alpha.Beta()方法：

Alpha oAlpha = new Alpha();
Thread oThread = new Thread(new ThreadStart(oAlpha.Beta));
oThread.Start();

      然后在Main()函數的while循環中，我們使用靜態方法Thread.Sleep()讓主線程停了1ms，這段時間CPU轉向執行線程oThread。然后我們試圖用Thread.Abort()方法終止線程oThread，注意后面的oThread.Join()，Thread.Join()方法使主線程等待，直到oThread線程結束。你可以給Thread.Join()方法指定一個int型的參數作為等待的最長時間。之后，我們試圖用Thread.Start()方法重新啟動線程oThread，但是顯然Abort()方法帶來的后果是不可恢復的終止線程，所以最后程序會拋出ThreadStateException異常。

主線程Main()函數

     所有線程都是依附於Main()函數所在的線程的，Main()函數是C#程序的入口，起始線程可以稱之為主線程。如果所有的前台線程都停止了，那么主線程可以終止，而所有的后台線程都將無條件終止。所有的線程雖然在微觀上是串行執行的，但是在宏觀上你完全可以認為它們在並行執行。

Thread.ThreadState 屬性

     這個屬性代表了線程運行時狀態，在不同的情況下有不同的值，我們有時候可以通過對該值的判斷來設計程序流程。

ThreadState 屬性的取值如下：

Aborted：線程已停止；

AbortRequested：線程的Thread.Abort()方法已被調用，但是線程還未停止；

Background：線程在后台執行，與屬性Thread.IsBackground有關；

Running：線程正在正常運行；

Stopped：線程已經被停止；

StopRequested：線程正在被要求停止；

Suspended：線程已經被掛起（此狀態下，可以通過調用Resume()方法重新運行）；

SuspendRequested：線程正在要求被掛起，但是未來得及響應；

Unstarted：未調用Thread.Start()開始線程的運行；

WaitSleepJoin：線程因為調用了Wait(),Sleep()或Join()等方法處於封鎖狀態；

     上面提到了Background狀態表示該線程在后台運行，那么后台運行的線程有什么特別的地方呢？其實后台線程跟前台線程只有一個區別，那就是后台線程不妨礙程序的終止。一旦一個進程所有的前台線程都終止后，CLR（通用語言運行環境）將通過調用任意一個存活中的后台進程的Abort()方法來徹底終止進程。

線程的優先級

     當線程之間爭奪CPU時間時，CPU 是按照線程的優先級給予服務的。在C#應用程序中，用戶可以設定5個不同的優先級，由高到低分別是Highest，AboveNormal，Normal，BelowNormal，Lowest，在創建線程時如果不指定優先級，那么系統默認為ThreadPriority.Normal。

     給一個線程指定優先級，我們可以使用如下代碼：

//設定優先級為最低
myThread.Priority=ThreadPriority.Lowest;

      通過設定線程的優先級，我們可以安排一些相對重要的線程優先執行，例如對用戶的響應等等。

C#多線程學習(三) 生產者和消費者

      前面說過，每個線程都有自己的資源，但是代碼區是共享的，即每個線程都可以執行相同的函數。這可能帶來的問題就是幾個線程同時執行一個函數，導致數據的混亂，產生不可預料的結果，因此我們必須避免這種情況的發生。

      C#提供了一個關鍵字lock，它可以把一段代碼定義為互斥段（critical section），互斥段在一個時刻內只允許一個線程進入執行，而其他線程必須等待。在C#中，關鍵字lock定義如下：

lock(expression) statement_block

expression代表你希望跟蹤的對象，通常是對象引用。

• 如果你想保護一個類的實例，一般地，你可以使用this；
• 如果你想保護一個靜態變量（如互斥代碼段在一個靜態方法內部），一般使用類名就可以了。

而statement_block就是互斥段的代碼，這段代碼在一個時刻內只可能被一個線程執行。

下面是一個使用lock關鍵字的典型例子，在注釋里說明了lock關鍵字的用法和用途。

示例如下：

using System;
using System.Threading;

namespace ThreadSimple
{
    internal class Account 
    {
        int balance;
        Random r = new Random();
        
        internal Account(int initial) 
        {
            balance = initial;
        } 
        internal int Withdraw(int amount) 
        {
            if (balance < 0)
            {
                //如果balance小於0則拋出異常
                throw new Exception("Negative Balance");
            }
            //下面的代碼保證在當前線程修改balance的值完成之前
            //不會有其他線程也執行這段代碼來修改balance的值
            //因此，balance的值是不可能小於0 的
            lock (this)
            {
                Console.WriteLine("Current Thread:"+Thread.CurrentThread.Name);
                //如果沒有lock關鍵字的保護，那么可能在執行完if的條件判斷之后
                //另外一個線程卻執行了balance=balance-amount修改了balance的值
                //而這個修改對這個線程是不可見的，所以可能導致這時if的條件已經不成立了
                //但是，這個線程卻繼續執行balance=balance-amount，所以導致balance可能小於0
                if (balance >= amount) 
                {
                    Thread.Sleep(5);
                    balance = balance - amount;
                    return amount;
                } 
                else 
                {
                    return 0; // transaction rejected
                  }
            }
        }
        internal void DoTransactions() 
        {
            for (int i = 0; i < 100; i++) 
            Withdraw(r.Next(-50, 100));
        }
    } 
    internal class Test 
    {
        static internal Thread[] threads = new Thread[10];
        public static void Main() 
        {
            Account acc = new Account (0);
            for (int i = 0; i < 10; i++) 
            {
                Thread t = new Thread(new ThreadStart(acc.DoTransactions));
                threads[i] = t;
            }
            for (int i = 0; i < 10; i++) 
                threads[i].Name=i.ToString();
            for (int i = 0; i < 10; i++) 
                threads[i].Start();
            Console.ReadLine();
        }
    }
}

Monitor 類鎖定一個對象

      當多線程公用一個對象時，也會出現和公用代碼類似的問題，這種問題就不應該使用lock關鍵字了，這里需要用到System.Threading中的一個類Monitor，我們可以稱之為監視器，Monitor提供了使線程共享資源的方案。

      Monitor類可以鎖定一個對象，一個線程只有得到這把鎖才可以對該對象進行操作。對象鎖機制保證了在可能引起混亂的情況下一個時刻只有一個線程可以訪問這個對象。 Monitor必須和一個具體的對象相關聯，但是由於它是一個靜態的類，所以不能使用它來定義對象，而且它的所有方法都是靜態的，不能使用對象來引用。下面代碼說明了使用Monitor鎖定一個對象的情形：

......

Queue oQueue=new Queue();

......

Monitor.Enter(oQueue);

......//現在oQueue對象只能被當前線程操縱了

Monitor.Exit(oQueue);//釋放鎖

     如上所示，當一個線程調用Monitor.Enter()方法鎖定一個對象時，這個對象就歸它所有了，其它線程想要訪問這個對象，只有等待它使用Monitor.Exit()方法釋放鎖。為了保證線程最終都能釋放鎖，你可以把Monitor.Exit()方法寫在try-catch-finally結構中的finally代碼塊里。  

對於任何一個被Monitor鎖定的對象，內存中都保存着與它相關的一些信息:

• 其一是現在持有鎖的線程的引用;
• 其二是一個預備隊列，隊列中保存了已經准備好獲取鎖的線程;
• 其三是一個等待隊列，隊列中保存着當前正在等待這個對象狀態改變的隊列的引用。

     當擁有對象鎖的線程准備釋放鎖時，它使用Monitor.Pulse()方法通知等待隊列中的第一個線程，於是該線程被轉移到預備隊列中，當對象鎖被釋放時，在預備隊列中的線程可以立即獲得對象鎖。

     下面是一個展示如何使用lock關鍵字和Monitor類來實現線程的同步和通訊的例子，也是一個典型的生產者與消費者問題。

      這個例程中，生產者線程和消費者線程是交替進行的，生產者寫入一個數，消費者立即讀取並且顯示（注釋中介紹了該程序的精要所在）。

     用到的系統命名空間如下：

using System;

using System.Threading;

      首先，定義一個被操作的對象的類Cell，在這個類里，有兩個方法：ReadFromCell()和WriteToCell。消費者線程將調用ReadFromCell()讀取cellContents的內容並且顯示出來，生產者進程將調用WriteToCell()方法向cellContents寫入數據。

示例如下：

public class Cell
{
        int cellContents; // Cell對象里邊的內容
        bool readerFlag = false; // 狀態標志，為true時可以讀取，為false則正在寫入
        public int ReadFromCell( )
        {
            lock(this) // Lock關鍵字保證了什么，請大家看前面對lock的介紹
            {
                if (!readerFlag)//如果現在不可讀取
                { 
                    try
                    {
                        //等待WriteToCell方法中調用Monitor.Pulse()方法
                        Monitor.Wait(this);
                    }
                    catch (SynchronizationLockException e)
                    {
                        Console.WriteLine(e);
                    }
                    catch (ThreadInterruptedException e)
                    {
                        Console.WriteLine(e);
                    }
                }
                Console.WriteLine("Consume: {0}",cellContents);
                readerFlag = false;
                //重置readerFlag標志，表示消費行為已經完成
                Monitor.Pulse(this); 
                //通知WriteToCell()方法（該方法在另外一個線程中執行，等待中）
            }
            return cellContents;
        }
    
        public void WriteToCell(int n)
        {
            lock(this)
            {
                if (readerFlag)
                {
                    try
                    {
                        Monitor.Wait(this);
                    }
                    catch (SynchronizationLockException e)
                    {
                            //當同步方法（指Monitor類除Enter之外的方法）在非同步的代碼區被調用
                        Console.WriteLine(e);
                    }
                    catch (ThreadInterruptedException e)
                    {
                            //當線程在等待狀態的時候中止 
                        Console.WriteLine(e);
                    }
                }
                cellContents = n;
                Console.WriteLine("Produce: {0}",cellContents);
                readerFlag = true; 
                Monitor.Pulse(this); 
                //通知另外一個線程中正在等待的ReadFromCell()方法
            }
        }
}
下面定義生產者類 CellProd 和消費者類 CellCons ，它們都只有一個方法ThreadRun()，以便在Main()函數中提供給線程的ThreadStart代理對象，作為線程的入口。
public class CellProd
{
　　    Cell cell; // 被操作的Cell對象
　　    int quantity = 1; // 生產者生產次數，初始化為1 

　　    public CellProd(Cell box, int request)
　　    {
        //構造函數
        cell = box; 
        quantity = request; 
　　    }
　　    public void ThreadRun( )
　　    {
        for(int looper=1; looper<=quantity; looper++)
　　　　        cell.WriteToCell(looper); //生產者向操作對象寫入信息
　　    }
}

public class CellCons
{
　　    Cell cell; 
　　    int quantity = 1; 

　　    public CellCons(Cell box, int request)
　　    {
                //構造函數
        cell = box; 
        quantity = request; 
　　    }
　　    public void ThreadRun( )
　　    {
        int valReturned;
        for(int looper=1; looper<=quantity; looper++)
　　　　        valReturned=cell.ReadFromCell( );//消費者從操作對象中讀取信息
　　    }
} 

      然后在下面這個類MonitorSample的Main()函數中，我們要做的就是創建兩個線程分別作為生產者和消費者，使用CellProd.ThreadRun()方法和CellCons.ThreadRun()方法對同一個Cell對象進行操作。

public class MonitorSample
{
　　    public static void Main(String[] args)
　　    {
        int result = 0; //一個標志位，如果是0表示程序沒有出錯，如果是1表明有錯誤發生
        Cell cell = new Cell( ); 

        //下面使用cell初始化CellProd和CellCons兩個類，生產和消費次數均為20次
        CellProd prod = new CellProd(cell, 20); 
        CellCons cons = new CellCons(cell, 20); 

        Thread producer = new Thread(new ThreadStart(prod.ThreadRun));
        Thread consumer = new Thread(new ThreadStart(cons.ThreadRun));
        //生產者線程和消費者線程都已經被創建，但是沒有開始執行 
        try
        {
　　　　    producer.Start( );
　　　　    consumer.Start( ); 

　　　　    producer.Join( ); 
　　　　    consumer.Join( );
　　　　    Console.ReadLine();
        }
        catch (ThreadStateException e)
        {
　　　　    //當線程因為所處狀態的原因而不能執行被請求的操作
　　　　    Console.WriteLine(e); 
　　　　    result = 1; 
        }
        catch (ThreadInterruptedException e)
        {
　　　　    //當線程在等待狀態的時候中止
　　　　    Console.WriteLine(e); 
　　　　    result = 1; 
        }
        //盡管Main()函數沒有返回值，但下面這條語句可以向父進程返回執行結果
        Environment.ExitCode = result;
　　    }
}

      在上面的例程中，同步是通過等待Monitor.Pulse()來完成的。首先生產者生產了一個值，而同一時刻消費者處於等待狀態，直到收到生產者的“脈沖(Pulse)”通知它生產已經完成，此后消費者進入消費狀態，而生產者開始等待消費者完成操作后將調用Monitor.Pulese()發出的“脈沖”。

它的執行結果很簡單：

Produce: 1

Consume: 1

Produce: 2

Consume: 2

Produce: 3

Consume: 3

...

...

Produce: 20

Consume: 20

     事實上，這個簡單的例子已經幫助我們解決了多線程應用程序中可能出現的大問題，只要領悟了解決線程間沖突的基本方法，很容易把它應用到比較復雜的程序中去。

C#多線程學習(四) 多線程的自動管理(線程池)

在多線程的程序中，經常會出現兩種情況：

• 一種情況： 應用程序中，線程把大部分的時間花費在等待狀態，等待某個事件發生，然后才能給予響應

這一般使用ThreadPool（線程池）來解決；

• 另一種情況：線程平時都處於休眠狀態，只是周期性地被喚醒

這一般使用Timer（定時器）來解決；

      ThreadPool類提供一個由系統維護的線程池（可以看作一個線程的容器），該容器需要 Windows 2000 以上系統支持，因為其中某些方法調用了只有高版本的Windows才有的API函數。

將線程安放在線程池里，需使用ThreadPool.QueueUserWorkItem()方法，該方法的原型如下：

//將一個線程放進線程池，該線程的Start()方法將調用WaitCallback代理對象代表的函數

public static bool QueueUserWorkItem(WaitCallback);

//重載的方法如下，參數object將傳遞給WaitCallback所代表的方法

public static bool QueueUserWorkItem(WaitCallback, object);

     ThreadPool類是一個靜態類，你不能也不必要生成它的對象。而且一旦使用該方法在線程池中添加了一個項目，那么該項目將是無法取消的。

     在這里你無需自己建立線程，只需把你要做的工作寫成函數，然后作為參數傳遞給ThreadPool.QueueUserWorkItem()方法就行了，傳遞的方法就是依靠WaitCallback代理對象，而線程的建立、管理、運行等工作都是由系統自動完成的，你無須考慮那些復雜的細節問題。

ThreadPool 的用法：

      首先程序創建了一個ManualResetEvent對象，該對象就像一個信號燈，可以利用它的信號來通知其它線程。

本例中，當線程池中所有線程工作都完成以后，ManualResetEvent對象將被設置為有信號，從而通知主線程繼續運行。

ManualResetEvent對象有幾個重要的方法：

初始化該對象時，用戶可以指定其默認的狀態（有信號/無信號）；

在初始化以后，該對象將保持原來的狀態不變，直到它的Reset()或者Set()方法被調用：

Reset()方法：將其設置為無信號狀態；

Set()方法：將其設置為有信號狀態。

WaitOne()方法：使當前線程掛起，直到ManualResetEvent對象處於有信號狀態，此時該線程將被激活。然后，程序將向線程池中添加工作項，這些以函數形式提供的工作項被系統用來初始化自動建立的線程。當所有的線程都運行完了以后，ManualResetEvent.Set()方法被調用，因為調用了ManualResetEvent.WaitOne()方法而處在等待狀態的主線程將接收到這個信號，於是它接着往下執行，完成后邊的工作。

ThreadPool 的用法示例：

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

namespace ThreadExample
{
    //這是用來保存信息的數據結構，將作為參數被傳遞
    public class SomeState
    {
　　    public int Cookie;
　　    public SomeState(int iCookie)
　　    {
        Cookie = iCookie;
　　    }
    }

    public class Alpha
    {
　　public Hashtable HashCount;
　　public ManualResetEvent eventX;
　　public static int iCount = 0;
　　public static int iMaxCount = 0;
　　
        public Alpha(int MaxCount) 
　　{
　        HashCount = new Hashtable(MaxCount);
　        iMaxCount = MaxCount;
　　}

　　//線程池里的線程將調用Beta()方法
　　public void Beta(Object state)
　　{
　　    //輸出當前線程的hash編碼值和Cookie的值
　        Console.WriteLine(" {0} {1} :", Thread.CurrentThread.GetHashCode(),((SomeState)state).Cookie);
      Console.WriteLine("HashCount.Count=={0}, Thread.CurrentThread.GetHashCode()=={1}", HashCount.Count, Thread.CurrentThread.GetHashCode());
      lock (HashCount) 
      {
　　　　    //如果當前的Hash表中沒有當前線程的Hash值，則添加之
　　　　    if (!HashCount.ContainsKey(Thread.CurrentThread.GetHashCode()))
　　      　    HashCount.Add (Thread.CurrentThread.GetHashCode(), 0);
　  　　    HashCount[Thread.CurrentThread.GetHashCode()] = 
            ((int)HashCount[Thread.CurrentThread.GetHashCode()])+1;
　    　}
          int iX = 2000;
          Thread.Sleep(iX);
          //Interlocked.Increment()操作是一個原子操作，具體請看下面說明
          Interlocked.Increment(ref iCount);

          if (iCount == iMaxCount)
          {
　    　    Console.WriteLine();
　　　　    Console.WriteLine("Setting eventX ");
　　　　    eventX.Set();
   　    }
　　  }
  }

        public class SimplePool
        {
            public static int Main(string[] args)
            {
                Console.WriteLine("Thread Pool Sample:");
                bool W2K = false;
                int MaxCount = 10;//允許線程池中運行最多10個線程
                //新建ManualResetEvent對象並且初始化為無信號狀態
                ManualResetEvent eventX = new ManualResetEvent(false);
                Console.WriteLine("Queuing {0} items to Thread Pool", MaxCount);
                Alpha oAlpha = new Alpha(MaxCount); 
                //創建工作項
                //注意初始化oAlpha對象的eventX屬性
                oAlpha.eventX = eventX;
                Console.WriteLine("Queue to Thread Pool 0");
                try
                {
                    //將工作項裝入線程池 
                    //這里要用到Windows 2000以上版本才有的API，所以可能出現NotSupportException異常
                    ThreadPool.QueueUserWorkItem(new WaitCallback(oAlpha.Beta), new SomeState(0));
                    W2K = true;
                }
                catch (NotSupportedException)
                {
                    Console.WriteLine("These API's may fail when called on a non-Windows 2000 system.");
                    W2K = false;
                }
                if (W2K)//如果當前系統支持ThreadPool的方法.
                {
                    for (int iItem=1;iItem < MaxCount;iItem++)
                    {
                        //插入隊列元素
                        Console.WriteLine("Queue to Thread Pool {0}", iItem);
                        ThreadPool.QueueUserWorkItem(new WaitCallback(oAlpha.Beta), new SomeState(iItem));
                    }
                    Console.WriteLine("Waiting for Thread Pool to drain");
                    //等待事件的完成，即線程調用ManualResetEvent.Set()方法
                    eventX.WaitOne(Timeout.Infinite,true);
                    //WaitOne()方法使調用它的線程等待直到eventX.Set()方法被調用
                    Console.WriteLine("Thread Pool has been drained (Event fired)");
                    Console.WriteLine();
                    Console.WriteLine("Load across threads");
                    foreach(object o in oAlpha.HashCount.Keys)
                        Console.WriteLine("{0} {1}", o, oAlpha.HashCount[o]);
                }
                Console.ReadLine();
                return 0;
            }
        }
    }
}

程序中應該引起注意的地方：

      SomeState類是一個保存信息的數據結構，它在程序中作為參數被傳遞給每一個線程，因為你需要把一些有用的信息封裝起來提供給線程，而這種方式是非常有效的。

      程序出現的InterLocked類也是專為多線程程序而存在的，它提供了一些有用的原子操作。

      原子操作：就是在多線程程序中，如果這個線程調用這個操作修改一個變量，那么其他線程就不能修改這個變量了，這跟lock關鍵字在本質上是一樣的。

Thread Pool Sample:
Queuing 10 items to Thread Pool
Queue to Thread Pool 0
Queue to Thread Pool 1
Queue to Thread Pool 2
Queue to Thread Pool 3
Queue to Thread Pool 4
Queue to Thread Pool 5
 2 0 :
HashCount.Count==0, Thread.CurrentThread.GetHashCode()==2
Queue to Thread Pool 6
Queue to Thread Pool 7
Queue to Thread Pool 8
Queue to Thread Pool 9
Waiting for Thread Pool to drain
 4 1 :
HashCount.Count==1, Thread.CurrentThread.GetHashCode()==4
 6 2 :
HashCount.Count==1, Thread.CurrentThread.GetHashCode()==6
 7 3 :
HashCount.Count==1, Thread.CurrentThread.GetHashCode()==7
 2 4 :
HashCount.Count==1, Thread.CurrentThread.GetHashCode()==2
 8 5 :
HashCount.Count==2, Thread.CurrentThread.GetHashCode()==8
 9 6 :
HashCount.Count==2, Thread.CurrentThread.GetHashCode()==9
 10 7 :
HashCount.Count==2, Thread.CurrentThread.GetHashCode()==10
 11 8 :
HashCount.Count==2, Thread.CurrentThread.GetHashCode()==11
 4 9 :
HashCount.Count==2, Thread.CurrentThread.GetHashCode()==4

Setting eventX
Thread Pool has been drained (Event fired)

Load across threads
11 1
10 1
9 1
8 1
7 1
6 1
4 2
2 2

      我們應該徹底地分析上面的程序，把握住線程池的本質，理解它存在的意義是什么，這樣才能得心應手地使用它。

C#多線程學習(五) 多線程的自動管理(定時器)

Timer類：設置一個定時器，定時執行用戶指定的函數。

定時器啟動后，系統將自動建立一個新的線程，執行用戶指定的函數。

初始化一個Timer對象：

Timer timer = new Timer(timerDelegate, s,1000, 1000);

// 第一個參數：指定了TimerCallback 委托，表示要執行的方法；

// 第二個參數：一個包含回調方法要使用的信息的對象，或者為空引用；

// 第三個參數：延遲時間——計時開始的時刻距現在的時間，單位是毫秒,指定為“0”表示立即啟動計時器；

// 第四個參數：定時器的時間間隔——計時開始以后，每隔這么長的一段時間，TimerCallback所代表的方法將被調用一次，單位也是毫秒。指定 Timeout.Infinite 可以禁用定期終止。

Timer.Change()方法：修改定時器的設置。（這是一個參數類型重載的方法）

使用示例： timer.Change(1000,2000);

Timer類的程序示例(來源：MSDN)：

using System;
using System.Threading;

namespace ThreadExample
{
    class TimerExampleState 
    {
　　    public int counter = 0;
　　    public Timer tmr;
    }

    class App 
    {
　　    public static void Main()
　　    {
　　        TimerExampleState s = new TimerExampleState();

　　        //創建代理對象TimerCallback，該代理將被定時調用
　　        TimerCallback timerDelegate = new TimerCallback(CheckStatus);

            //創建一個時間間隔為1s的定時器
            Timer timer = new Timer(timerDelegate, s,1000, 1000);
            s.tmr = timer;

            //主線程停下來等待Timer對象的終止
            while(s.tmr != null)
            Thread.Sleep(0);
            Console.WriteLine("Timer example done.");
            Console.ReadLine();
　　    }

　　    //下面是被定時調用的方法
　　    static void CheckStatus(Object state)
　　    {
            TimerExampleState s =(TimerExampleState)state;
            s.counter++;
            Console.WriteLine("{0} Checking Status {1}.",DateTime.Now.TimeOfDay, s.counter);

            if(s.counter == 5)
            {
                //使用Change方法改變了時間間隔
                (s.tmr).Change(10000,2000);
                Console.WriteLine("changed");
            }

            if(s.counter == 10)
            {
                Console.WriteLine("disposing of timer");
                s.tmr.Dispose();
                s.tmr = null;
            }
　　    }
    }
}

       程序首先創建了一個定時器，它將在創建1秒之后開始每隔1秒調用一次CheckStatus()方法，當調用5次以后，在CheckStatus()方法中修改了時間間隔為2秒，並且指定在10秒后重新開始。當計數達到10次，調用Timer.Dispose()方法刪除了timer對象，主線程於是跳出循環，終止程序。

C#多線程學習(六) 互斥對象

      如何控制好多個線程相互之間的聯系，不產生沖突和重復，這需要用到互斥對象，即：System.Threading 命名空間中的 Mutex 類。

      我們可以把Mutex看作一個出租車，乘客看作線程。乘客首先等車，然后上車，最后下車。當一個乘客在車上時，其他乘客就只有等他下車以后才可以上車。而線程與Mutex對象的關系也正是如此，線程使用Mutex.WaitOne()方法等待Mutex對象被釋放，如果它等待的Mutex對象被釋放了，它就自動擁有這個對象，直到它調用Mutex.ReleaseMutex()方法釋放這個對象，而在此期間，其他想要獲取這個Mutex對象的線程都只有等待。

      下面這個例子使用了Mutex對象來同步四個線程，主線程等待四個線程的結束，而這四個線程的運行又是與兩個Mutex對象相關聯的。

      其中還用到AutoResetEvent類的對象，可以把它理解為一個信號燈。這里用它的有信號狀態來表示一個線程的結束。

// AutoResetEvent.Set()方法設置它為有信號狀態

// AutoResetEvent.Reset()方法設置它為無信號狀態

Mutex 類的程序示例：

using System;
using System.Threading;

namespace ThreadExample
{
    public class MutexSample
    {
　　    static Mutex gM1;
　　    static Mutex gM2;
　　    const int ITERS = 100;
　　    static AutoResetEvent Event1 = new AutoResetEvent(false);
　　    static AutoResetEvent Event2 = new AutoResetEvent(false);
　　    static AutoResetEvent Event3 = new AutoResetEvent(false);
　　    static AutoResetEvent Event4 = new AutoResetEvent(false);

　　    public static void Main(String[] args)
　　    {
            Console.WriteLine("Mutex Sample ");
            //創建一個Mutex對象，並且命名為MyMutex
            gM1 = new Mutex(true,"MyMutex");
            //創建一個未命名的Mutex 對象.
            gM2 = new Mutex(true);
            Console.WriteLine(" - Main Owns gM1 and gM2");

            AutoResetEvent[] evs = new AutoResetEvent[4];
            evs[0] = Event1; //為后面的線程t1,t2,t3,t4定義AutoResetEvent對象
            evs[1] = Event2; 
            evs[2] = Event3; 
            evs[3] = Event4; 

            MutexSample tm = new MutexSample( );
            Thread t1 = new Thread(new ThreadStart(tm.t1Start));
            Thread t2 = new Thread(new ThreadStart(tm.t2Start));
            Thread t3 = new Thread(new ThreadStart(tm.t3Start));
            Thread t4 = new Thread(new ThreadStart(tm.t4Start));
            t1.Start( );// 使用Mutex.WaitAll()方法等待一個Mutex數組中的對象全部被釋放
            t2.Start( );// 使用Mutex.WaitOne()方法等待gM1的釋放
            t3.Start( );// 使用Mutex.WaitAny()方法等待一個Mutex數組中任意一個對象被釋放
            t4.Start( );// 使用Mutex.WaitOne()方法等待gM2的釋放

            Thread.Sleep(2000);
            Console.WriteLine(" - Main releases gM1");
            gM1.ReleaseMutex( ); //線程t2,t3結束條件滿足

            Thread.Sleep(1000);
            Console.WriteLine(" - Main releases gM2");
            gM2.ReleaseMutex( ); //線程t1,t4結束條件滿足

            //等待所有四個線程結束
            WaitHandle.WaitAll(evs); 
            Console.WriteLine(" Mutex Sample");
            Console.ReadLine();
　　    }

　　    public void t1Start( )
　　    {
            Console.WriteLine("t1Start started, Mutex.WaitAll(Mutex[])");
            Mutex[] gMs = new Mutex[2];
            gMs[0] = gM1;//創建一個Mutex數組作為Mutex.WaitAll()方法的參數
            gMs[1] = gM2;
            Mutex.WaitAll(gMs);//等待gM1和gM2都被釋放
            Thread.Sleep(2000);
            Console.WriteLine("t1Start finished, Mutex.WaitAll(Mutex[]) satisfied");
            Event1.Set( ); //線程結束，將Event1設置為有信號狀態
　　    }
　　    public void t2Start( )
　　    {
            Console.WriteLine("t2Start started, gM1.WaitOne( )");
            gM1.WaitOne( );//等待gM1的釋放
            Console.WriteLine("t2Start finished, gM1.WaitOne( ) satisfied");
            Event2.Set( );//線程結束，將Event2設置為有信號狀態
　　    }
　　    public void t3Start( )
　　    {
            Console.WriteLine("t3Start started, Mutex.WaitAny(Mutex[])");
            Mutex[] gMs = new Mutex[2];
            gMs[0] = gM1;//創建一個Mutex數組作為Mutex.WaitAny()方法的參數
            gMs[1] = gM2;
            Mutex.WaitAny(gMs);//等待數組中任意一個Mutex對象被釋放
            Console.WriteLine("t3Start finished, Mutex.WaitAny(Mutex[])");
            Event3.Set( );//線程結束，將Event3設置為有信號狀態
　　    }
　　    public void t4Start( )
　　    {
            Console.WriteLine("t4Start started, gM2.WaitOne( )");
            gM2.WaitOne( );//等待gM2被釋放
            Console.WriteLine("t4Start finished, gM2.WaitOne( )");
            Event4.Set( );//線程結束，將Event4設置為有信號狀態
　　    }
    }
}

程序的輸出結果：

Mutex Sample 
 - Main Owns gM1 and gM2
t1Start started, Mutex.WaitAll(Mutex[])
t2Start started, gM1.WaitOne( )
t3Start started, Mutex.WaitAny(Mutex[])
t4Start started, gM2.WaitOne( )
 - Main releases gM1
t2Start finished, gM1.WaitOne( ) satisfied
t3Start finished, Mutex.WaitAny(Mutex[])
 - Main releases gM2
t1Start finished, Mutex.WaitAll(Mutex[]) satisfied
t4Start finished, gM2.WaitOne( )
 Mutex Sample

      從執行結果可以很清楚地看到，線程t2,t3的運行是以gM1的釋放為條件的，而t4在gM2釋放后開始執行，t1則在gM1和gM2都被釋放了之后才執行。Main()函數最后，使用WaitHandle等待所有的AutoResetEvent對象的信號，這些對象的信號代表相應線程的結束。

結束...