C#中利用委托實作多線程跨線程操作

C#中利用委托實作多線程跨線程操作

- 張小魚 2010-10-22 08:38

在使用VS2005的時候，如果你從非建立這個控件的線程中通路這個控件或者操作這個控件的話就會抛出這個異常。這是微軟為了保證線程安全以及提高代碼的效率所做的改進，但是也給大家帶來很多不便。

其實解決這個問題有兩種方法：

一，是通過設定

System.Windows.Forms.Control.CheckForIllegalCrossThreadCalls = false;

在你的程式初始化的時候設定了這個屬性，而且在你的控件中使用的都是微軟Framework類庫中的控件的話，系統就不會再抛出你上面所說的這個錯誤了。

二，就是委托了，個人建議用這種方法

首先在WinForm窗體中拖入 ListBox控件，然後參照以下代碼：

Thread t1;//聲明一個全局線程 private void Form1_Load(object sender, EventArgs e) { t1 = new Thread(new ThreadStart(BackgroundProcess)); t1.Start(); //開始 } delegate void aa(); private void BackgroundProcess() { // 将委托執行個體化 aa a= delegate() { for (int i = 0; i < 50; i++) { listBox1.Items.Add("Iterations: " + i.ToString()); Thread.Sleep(300); listBox1.Refresh(); } }; listBox1.Invoke(a); }

來源：http://www.huomo.cn/developer/article-1aa8.html

C#多線程操作界面控件的解決方案

我們在做winform應用的時候，大部分情況下都會碰到使用多線程控制界面上控件資訊的問題。然而我們并不能用傳統方法來做這個問題，下面我将詳細的介紹。­

      首先來看傳統方法：

public partial class Form1 : Form­ {­ public Form1()­ {­ InitializeComponent();­ }­ private void Form1_Load(object sender, EventArgs e)­ {­ Thread thread = new Thread(ThreadFuntion);­ thread.IsBackground = true;­ thread.Start();­ }­ private void ThreadFuntion()­ {­ while (true)­ {­ this.textBox1.Text = DateTime.Now.ToString();­ Thread.Sleep(1000);­ }­ }­ }­

運作這段 代碼，我們會看到系統抛出一個異常：Cross-thread operation not valid:Control 'textBox1' accessed from a thread other than the thread it was created on . 這是因為.net 2.0以後加強了安全機制，不允許在winform中直接跨線程通路控件的屬性。那麼怎麼解決這個問題呢，下面提供幾種方案。­

      第一種方案，我們在Form1_Load()方法中加一句代碼：­

private void Form1_Load(object sender, EventArgs e)­ {­ Control.CheckForIllegalCrossThreadCalls = false;­ Thread thread = new Thread(ThreadFuntion);­ thread.IsBackground = true;­ thread.Start();­ }­

加入這句代碼以後發現程式可以正常運作了。這句代碼就是說在這個類中我們不檢查跨線程的調用是否 合法（如果沒有加這句話運作也沒有異常，那麼說明系統以及預設的采用了不檢查的方式）。然而，這種方法不可取。我們檢視 CheckForIllegalCrossThreadCalls 這個屬性的定義，就會發現它是一個static的，也就是說無論我們在項目的什麼地方修改了這個值，他就會在全局起作用。而且像這種跨線程通路是否存在異 常，我們通常都會去檢查。如果項目中其他人修改了這個屬性，那麼我們的方案就失敗了，我們要采取另外的方案。­

      下面來看第二種方案，就是使用delegate和invoke來從其他線程中控制控件資訊。網上有很多人寫了這種控制方式，然而我看了很多這種文章，表明上看來是沒有什麼問題的，但是實際上并沒有解決這個問題，首先來看網絡上的那種不完善的方式：­

public partial class Form1 : Form­ {­ private delegate void FlushClient();//代理­ public Form1()­ {­ InitializeComponent();­ }­ private void Form1_Load(object sender, EventArgs e)­ {­ Thread thread = new Thread(CrossThreadFlush);­ thread.IsBackground=true;­ thread.Start();­ }­ private void CrossThreadFlush()­ {­ //将代理綁定到方法 ­ FlushClient fc = new FlushClient(ThreadFuntion);­ this.BeginInvoke(fc);//調用代理­ }­ private void ThreadFuntion()­ {­ while (true)­ {­ this.textBox1.Text = DateTime.Now.ToString();­ Thread.Sleep(1000);­ }­ }­ }­

使用這種方式我們可以看到跨線程通路的異常沒有了。但是新問題出現了，界面沒有響應了。為什麼會出現這個問題，我們隻是讓新開的線程無限循環重新整理，理論上 應該不會對主線程産生影響的。其實不然，這種方式其實相當于把這個新開的線程“注入”到了主要制線程中，它取得了主線程的控制。隻要這個線程不傳回，那麼 主線程将永遠都無法響應。就算新開的線程中不使用無限循環，使可以傳回了。這種方式的使用多線程也失去了它本來的意義。 ­

      現在來讓我們看看推薦的解決方案：­

public partial class Form1 : Form­ {­ private delegate void FlushClient();//代理­ public Form1()­ {­ InitializeComponent();­ }­ private void Form1_Load(object sender, EventArgs e)­ {­ Thread thread = new Thread(CrossThreadFlush);­ thread.IsBackground = true;­ thread.Start();­ }­ private void CrossThreadFlush()­ {­ while (true)­ {­ //将sleep和無限循環放在等待異步的外面­ Thread.Sleep(1000);­ ThreadFunction();­ }­ }­ private void ThreadFunction()­ {­ if (this.textBox1.InvokeRequired)//等待異步­ {­ FlushClient fc = new FlushClient(ThreadFunction);­ this.Invoke(fc);//通過代理調用重新整理方法­ }­ else­ {­ this.textBox1.Text = DateTime.Now.ToString();­ }­ }­ }­

運作上述代碼，我們可以看到問題已經被解決了，通過等待異步，我們就不會總是持有主線程的控制，這樣就可以在不發生跨線程調用異常的情況下完成多線程對winform多線程控件的控制了。­

      對于深山老林提出的問題,我最近找到了更優的解決方案,利用了delegate的異步調用，大家可以看看：­

public partial class Form1 : Form­ {­ private delegate void FlushClient();//代理­ public Form1()­ {­ InitializeComponent();­ }­ private void Form1_Load(object sender, EventArgs e)­ {­ Thread thread = new Thread(CrossThreadFlush);­ thread.IsBackground = true;­ thread.Start();­ }­ private void CrossThreadFlush()­ {­ FlushClient=new FlushClient(ThreadFunction);­ FlushClient.BeginInvoke(null,null);­ }­ private void ThreadFunction()­ {­ while (true)­ {­ this.textBox1.Text = DateTime.Now.ToString();­ Thread.Sleep(1000);­ }­ ­ }­ }­

這種方法也可以直接簡化為(因為delegate的異步就是開了一個異步線程): ­

public partial class Form1 : Form­ {­ private delegate void FlushClient();//代理­ public Form1()­ {­ InitializeComponent();­ }­ private void Form1_Load(object sender, EventArgs e)­ {­ Thread thread = new Thread(CrossThreadFlush);­ FlushClient=new FlushClient(ThreadFunction); ­ FlushClient.BeginInvoke(null,null);­ }­ private void ThreadFunction()­ {­ while (true)­ {­ this.textBox1.Text = DateTime.Now.ToString();­ Thread.Sleep(1000);­ }­ ­ }­ }

  public  partial  class Form1 : Form

    {

         private  delegate  void ThreadWork( int i);

        Thread thread;

         public Form1()

        {

            InitializeComponent();

             //  CheckForIllegalCrossThreadCalls = false;

        }

         private  void button1_Click( object sender, EventArgs e)

        {

             this.richTextBox1.Text =  " 程式開始：\r\n ";

            UpdateText();

        }

         public  void UpdateText()

        {

            thread =  new Thread( new ThreadStart(CrossThreadFlush));

            thread.IsBackground =  true;

            thread.Start();

        }

         private  void CrossThreadFlush()

        {

             while ( true)

            {  // 将sleep和無限循環放在等待異步的外面 

                 for ( int i =  1; i <  100; i++)

                {

                    ThreadFunction(i);

                    Thread.Sleep( 500);

                }

            }

        }

         private  void ThreadFunction( int i)

        {

             if ( this.richTextBox1.InvokeRequired) // 等待異步 

            {

                ThreadWork fc =  new ThreadWork(ThreadFunction);

                //  this.Invoke(fc); // 通過代理調用重新整理方法 

                 this.Invoke(fc,  new  object[ 1] { i });

            }

             else

            {

                 this.richTextBox1.Text =  string.Format( " 第{0}個\t{1:mm-ss}\r\n ", i, DateTime.Now) +  this.richTextBox1.Text;

                 this.richTextBox1.Refresh();

            }

        }

    }

}

文章摘自：

C #中的幾個線程同步對象方法

- 張小魚 2010-10-22 08:40

在編寫多線程程式時無可避免會遇到線程的同步問題。什麼是線程的同步呢？

舉 個例子：如果在一個公司裡面有一個變量記錄某人T的工資count=100，有兩個主管A和B（即工作線程）在早一些時候拿了這個變量的值回去 ，過了一段時間A主管将T的工資加了5塊，并存回count變量，而B主管将T的工資減去3塊，并存回count變量。好了，本來T君可以得到102塊的 工資的，現在就變成98塊了。這就是線程同步要解決的問題。

在C#裡面用于實作線程同步的常用類有如下幾類 1、Mutex類（互斥器），Monitor類，lock方法 

2、ManualResetEvent類，AutoResetEvent類（這兩個都是由EventWaitHandle類派生出來的） 

3、ReaderWriterLock類

同 一類的作用都差不多：其中 代碼執行為止。就好比一堆人同時上一個公共廁所一樣，使用這個方法就可以解決文章一開始時提出的問題：主管A要處理T君的工資之前，先lock一下T君， 然後取出目前的count值，處理完之後再解除T君的鎖定。如果主管B在主管A處理工資時也想取出count值，那麼它隻能是一直地等待A處理完之後才能 繼續。使用這個方法的一個缺點就是會降低程式的效率。本來是一個多個線程的操作，一旦遇到lock的語句時，那麼這些線程隻要排隊處理，形同一個單線程操 作。

下面舉個例子說明一下這三個方法的使用： 

假定有一個Tools類，裡面一個int變量，還有Add和Delete方法，其中Add方法會使int變量的值增加，Delete方法使int變量值減少：

public class Tools private int count = 100; 

public void Add(int n) count+=n; 

}

public void Delete(int n) count-=n;

}

　 　在多個線程同時通路這段代碼時，因為一個語句會被編譯器編譯成多個指令，是以會可能出現這種情況：但某個線程調用Add方法時，這時的count值為 100，而正當要加上n的時候，另外一個線程調用了Delete，它要減去m，結果count加上了n，然後又在原先count=100的值的情況 

下減掉了m，最後的結果是count被減去了m,而沒有加上n。很明顯Add方法和Delete方法是不能同時被調用的，是以必須進行線程同步處理。簡單的方法是用lock語句：

public class Tools private object abcde = new object(); 

private int count = 100;

public void Add(int n) lock(abcde) count+=n; 

}

public void Delete(int n) lock(abcde) count-=n; }

　　其中abcde是一個private級的内部變量，它不表示任何的意義，隻是作為一種“令牌”的角色。 

當執行Add方法中的lock(abcde)方法時，這個令牌就在Add方法的手中了，如果這時有第二個線程也想拿這個令牌，沒門，惟有等待。一旦第一 

個lock語句的花括号範圍結束之後，這時令牌就被釋放了，同時會迅速落到第二個線程的手中，并且排除其他後來的人。

使用Monitor類的方法大緻一樣：

public class Tools private object abcde = new object(); 

private int count = 100;

public void Add(int n) Monitor.Enter(abcde); 

count+=n; 

Monitor.Exit(abcde); 

}

public void Delete(int n) Monitor.Enter(abcde); 

count-=n; 

Monitor.Exit(abcde); 

}

　　Monitor的常用方法：Enter和Exit都是靜态方法，作用跟lock語句的兩個花括号一樣。 

而使用 Mutex 就不需聲明一個“令牌”對象了，但要執行個體化之後才可以使用：

public class Tools

{ 

private Mutex mut = new Mutex(); 

private int count = 100;

public void Add(int n) mut.WaitOne(); 

count+=n; 

mut.ReleaseMutex(); 

}

public void Delete(int n) mut.WaitOne(); 

count-=n; 

mut.ReleaseMutex(); 

}

其中的WaitOne為等待方法，一直等到Mutex 被釋放為止。初始的情況下，Mutex 對象是處于釋放狀态的，而一旦執行了WaitOne方法之後，它 就被捕獲了，一直到被調用了ReleaseMutex方法之後才被釋放。 

使用這三種方法都有一個要注意的問題，就是在獨占代碼段裡面如果引起了異常，可能會使“令牌”對象不被釋放，這樣程式就會一直地死等下去了。

　　是以要在獨占代碼段裡面處理好異常。例如下面這樣的代碼就是錯誤的：

public void Add(int n) try mut.WaitOne(); 

count+=n; mut.ReleaseMutex(); catch Console.Writeline("error."); }

　　上面的代碼一旦在try和catch裡面發生了異常，那麼Mutex就不能被釋放，後面的程式就會卡死在WaitOne()一行，而應該改成這樣：

public void Add(int n) mut.WaitOne(); 

try count+=n; } 

catch Console.Writeline("error."); mut.ReleaseMutex(); 

}

現在談一下第二種： 

ManualResetEvent類，AutoResetEvent類

　　上面這兩個類都是由EventWaitHandle類派生出來的，是以功能和調用方法都很相似。 舉個例子，你想送花給一個MM，托了一個送花的小夥子送了過去，而你希望當MM收到花之後就立即打個電話過去告訴她。

　　但問題是你不知道花什麼時候才送到MM的手裡，打早了打遲了都不好，這時你可以使用ManualResetEvent對象幫忙。

當委托小夥子送花過去的時候，使用ManualResetEvent的WaitOne方法進行等待。當小夥子把花送到MM的手中時，再調用一下ManualResetEvent的Set方法，你就可以準時地打電話過去了。

另外ManualResetEvent還有一個Reset方法，用來重新阻斷調用者執行的，情況就好比你委托了這個小夥子送花給N個MM，

　　而又想準時地給這N個MM打電話的情況一樣。

using System; 

using System.Threading;

public class TestMain private static ManualResetEvent ent = new ManualResetEvent(false);

public static void Main() Boy sender = new Boy(ent); 

Thread th = new Thread(new ThreadStart(sender.SendFlower)); 

th.Start();

ent.WaitOne(); //等待工作 

Console.WriteLine("收到了吧，花是我送嘀:)"); 

Console.ReadLine();

public class Boy ManualResetEvent ent;

public Boy(ManualResetEvent e) ent = e; 

}

public void SendFlower() Console.WriteLine("正在送花的途中"); 

Thread.Sleep(2000);

Console.WriteLine("\r\n花已經送到MM手中了,boss");

ent.Set(); //通知阻塞程式 

}

　　而AutoResetEvent類故名思意，就是在每次Set完之後自動Reset。讓執行程式重新進入阻塞狀态。 

即AutoResetEvent.Set() 相當于 ManualResetEvent.Set() 之後又立即 ManualResetEvent.Reset()， 舉個送花給N個MM的例子：

using System; 

using System.Threading;

public class TestMain private static AutoResetEvent ent = new AutoResetEvent(false);

public static void Main() Boy sender = new Boy(ent);

for (int i = 0; i < 3; i++) Thread th = new Thread(new ThreadStart(sender.SendFlower)); 

th.Start(); 

ent.WaitOne(); //等待工作 

Console.WriteLine("收到了吧，花是我送嘀:)\r\n\r\n"); 

}

Console.ReadLine(); 

}

public class Boy AutoResetEvent ent;

public Boy(AutoResetEvent e) ent = e; 

}

public void SendFlower() Console.WriteLine("正在送花的途中"); 

Thread.Sleep(2000); 

Console.WriteLine("\r\n花已送到MM手中了,boss");

//通知阻塞程式,這裡的效果相當于 ManualResetEvent的Set()方法+Reset()方法

ent.Set();

}

要注意的是ManualResetEvent和AutoResetEvent 的構造函數都有一個bool的參數，用這個參數可以指定初始情況下，同步對象的處于阻塞（設定為false）還是非阻塞（設定為true）的狀态。

另外WaitOne方法也可以帶兩個參數： 

WaitOne (int millisecondsTimeout,bool exitContext) 

millisecondsTimeout：等待的毫秒數，或為 Timeout.Infinite (-1)，表示無限期等待。 

exitContext：為 true，則等待之前先退出上下文的同步域（如果在同步上下文中），然後在稍後重新擷取它；否則為false。

　　就是說，等待是可以加上一個期限的，如果等待的同步對象一直都不Set()的話，那麼程式就會卡死，是以在WaitOne方法裡面可以放置一個時間期限，機關是毫秒。 C#不同線程間通信，使用Control的Invoke和BeginInvoke的方法

- 張小魚 2010-10-22 08:41

Control的Invoke和BeginInvoke Control的Invoke和BeginInvoke

近日，被Control的Invoke和BeginInvoke搞的頭大，就查了些相關的資料，整理如下。

(一）Control的Invoke和BeginInvoke （1）Control的Invoke和BeginInvoke與Delegate的Invoke和BeginInvoke是不同的。

（2）Control的Invoke和BeginInvoke的參數為delegate，委托的方法是在Control的線程上執行的，也就是我們平時所說的UI線程。

我們以代碼(一)來看(Control的Invoke)

private delegate void InvokeDelegate();

private void InvokeMethod(){

   //C代碼段 private void butInvoke_Click(object sender, EventArgs e) {

   //A代碼段.......

   this.Invoke(new InvokeDelegate(InvokeMethod));

   //B代碼段...... 你覺得代碼的執行順序是什麼呢?記好Control的Invoke和BeginInvoke都執行在主線程即UI線程上

A------>C---------------->B

解釋：(1)A在UI線程上執行完後，開始Invoke，Invoke是同步

(2)代碼段B并不執行，而是立即在UI線程上執行InvokeMethod方法，即代碼段C。

(3)InvokeMethod方法執行完後，代碼段C才在UI線程上繼續執行。

看看代碼(二)，Control的BeginInvoke

private delegate void BeginInvokeDelegate();

private void BeginInvokeMethod(){

   //C代碼段 private void butBeginInvoke_Click(object sender, EventArgs e) {

   //A代碼段.......

   this.BeginInvoke(new BeginInvokeDelegate(BeginInvokeMethod));

   //B代碼段...... 你覺得代碼的執行順序是什麼呢?記好Control的Invoke和BeginInvoke都執行在主線程即UI線程上

A----------->B--------------->C慎重，這個隻做參考。。。。。，我也不肯定執行順序，如果有哪位達人知道的話請告知。

解釋：：(1)A在UI線程上執行完後，開始BeginInvoke，BeginInvoke是異步

(2)InvokeMethod方法，即代碼段C不會執行，而是立即在UI線程上執行代碼段B。

(3) 代碼段B執行完後(就是說butBeginInvoke_Click方法執行完後)，InvokeMethod方法，即代碼段C才在UI線程上繼續執行。 Control的Invoke和BeginInvoke的委托方法是在主線程，即UI線程上執行的。也就是說如果你的委托方法用來取花費時間長的資料，然 後更新界面什麼的，千萬别在UI線程上調用Control.Invoke和 Control.BeginInvoke，因為這些是依然阻塞UI線程的，造成界面的假死。異步是指相對于調用BeginInvoke的線程異步，而不是 相對于UI線程異步，你在UI線程上調用BeginInvoke ，當然不行了。－－－－摘自"Invoke和BeginInvoke的真正涵義"一文中的評論。

BeginInvoke的原理是将調用的方法Marshal成消息，然後調用Win32 API中的RegisterWindowMessage()向UI視窗發送消息。－－－－摘自"Invoke和BeginInvoke的真正涵義"一文中的評論。

(二)我們用Thread來調用BeginInvoke和Invoke

      我們開一個線程，讓線程執行一些耗費時間的操作，然後再用Control.Invoke和Control.BeginInvoke回到使用者UI線程，執行界面更新。

代碼(三) Thread調用Control的Invoke

private Thread invokeThread;

private delegate void invokeDelegate();

private void StartMethod(){

  //C代碼段......

   Control.Invoke(new invokeDelegate(invokeMethod));

//D代碼段...... private void invokeMethod(){

//E代碼段 private void butInvoke_Click(object sender, EventArgs e) {

   //A代碼段.......

  invokeThread = new Thread(new ThreadStart(StartMethod));

  invokeThread.Start();

   //B代碼段......

你覺得代碼的執行順序是什麼呢?記好Control的Invoke和BeginInvoke都執行在主線程即UI線程上

A------> (Start一開始B和StartMethod的C就同時執行)---->(C執行完了，不管B有沒有執行完，invokeThread把消息封送 (invoke)給UI線程，然後自己等待)---->UI線程處理完butInvoke_Click消息後，處理invokeThread封送過 來的消息，執行invokeMethod 方法，即代碼段E，處理往後UI線程切換到invokeThread線程。

這個Control.Invoke是相對于invokeThread線程同步的，阻止了其運作。 1。UI執行A

2。UI開線程InvokeThread，B和C同時執行，B執行線上程UI上，C執行線上程invokeThread上。

3。invokeThread封送消息給UI，然後自己等待，UI處理完消息後，處理invokeThread封送的消息，即代碼段E

4。UI執行完E後，轉到線程invokeThread上，invokeThread線程執行代碼段D

代碼(四) Thread調用Control的BeginInvoke

private Thread beginInvokeThread;

private delegate void beginInvokeDelegate();

private void StartMethod(){

  //C代碼段......

   Control.BeginInvoke(new beginInvokeDelegate(beginInvokeMethod));

//D代碼段...... private void beginInvokeMethod(){

//E代碼段 private void butBeginInvoke_Click(object sender, EventArgs e) {

   //A代碼段.......

  beginInvokeThread = new Thread(new ThreadStart(StartMethod));

  beginInvokeThread .Start();

   //B代碼段...... 你覺得代碼的執行順序是什麼呢?記好Control的Invoke和BeginInvoke都執行在主線程即UI線程上

A 在UI線程上執行----->beginInvokeThread線程開始執行，UI繼續執行代碼段B，并發地invokeThread執行代碼段 C-------------->不管UI有沒有執行完代碼段B，這時 beginInvokeThread線程把消息封送給UI，單自己并不等待，繼續向下執行-------->UI處理完 butBeginInvoke_Click消息後，處理beginInvokeThread線程封送過來的消息。解釋：

1。UI執行A

2。UI開線程beginInvokeThread，B和C同時執行，B執行線上程UI上，C執行線上程beginInvokeThread上。

3。beginInvokeThread封送消息給UI，然後自己繼續執行代碼D，UI處理完消息後，處理invokeThread封送的消息，即代碼段E

有點疑問：如果UI先執行完畢，是不是有可能過了段時間beginInvokeThread才把消息封送給UI，然後UI才繼續執行封送的消息E。如圖淺綠的部分。

Control 的BeginInvoke是相對于調用它的線程，即beginInvokeThread相對是異步的。 (1)如果你想阻止調用線程，那麼調用代碼(三)，代碼段D删掉，C改為耗費長時間的操作，因為這個操作是在另外一個線程中做的。代碼段E改為更新界面的 方法。

(2)如果你不想阻止調用線程，那麼調用代碼(四)，代碼段D删掉，C改為耗費長時間的操作，因為這個操作是在另外一個線程中做的。代碼段E改為更新界面的方法。

http://www.huomo.cn/developer/article-1aa5.html C#多線程程式設計(4)-多線程與UI操作

- 張小魚 2010-10-22 09:09

為了讓程式盡快響應使用者操作，在開發Windows應用程式時經常會使用到線程。對于耗時的操作如果不使用線程将會是UI界面長時間處于停滞狀态，這種情況是使用者非常不願意看到的，在這種情況下我們希望使用線程來解決這個問題。

下面是一個使用多線程操作界面UI的代碼：

using System; 

using System.Collections.Generic; 

using System.ComponentModel; 

using System.Data; 

using System.Drawing; 

using System.Text; 

using System.Windows.Forms; 

using System.Threading; 

namespacepublicpartialclasspublic ThreadForm() 

{ 

InitializeComponent(); 

} 

privatevoid btnThread_Click(object sender, EventArgs e) 

{ 

Thread thread =new Thread(new ThreadStart(Run)); 

thread.Start(); 

} 

privatevoidwhile (progressBar.Value < progressBar.Maximum) 

{ 

progressBar.PerformStep(); 

} 

} 

} 

}

程式的界面如下：

我 們的本意是點選“啟動”按鈕來啟動模拟一個操作，在進度條中顯示操作的總體進度。不過如果我們真的點選“啟動”按鈕會很失望，因為它會抛出一個 System.InvalidOperationException異常，異常描述就是“線程間操作無效: 從不是建立控件‘progressBar’的線程通路它。”

CheckForIllegalCrossThreadCalls屬性

之是以 會出現這樣的情況是因為在.NET中做了限制，不允許在調試環境下使用線程通路并非它自己建立的UI控件，這麼做可能是怕在多線程環境下對界面控件進行操 作會出現不可預知的情況，如果開發者可以确認自己的代碼操作界面不會出現問題，可以用比較簡單的方法解決，那就是設定 CheckForIllegalCrossThreadCalls這個靜态屬性，它預設是true，如果将其設為false的話，以後在多線程環境下操作 界面也不會抛出異常了，我們上面的代碼可以修改為：

using System; 

using System.Collections.Generic; 

using System.ComponentModel; 

using System.Data; 

using System.Drawing; 

using System.Linq; 

using System.Text; 

using System.Windows.Forms; 

using System.Threading; 

namespacepublicpartialclasspublic ThreadForm() 

{ 

InitializeComponent(); 

} 

privatevoid btnThread_Click(object//訓示是否對錯誤線程的調用，即是否允許在建立UI的線程之外通路線程

CheckForIllegalCrossThreadCalls =false=new Thread(new ThreadStart(Run)); 

thread.Start(); 

} 

privatevoidwhile (progressBar.Value < progressBar.Maximum) 

{ 

progressBar.PerformStep(); 

} 

} 

} 

}

這樣再執行程式就不會抛出異常了。

不過使用上面的代碼我們可能還有些犯嘀咕，畢竟是不允許直接線上程中直接操作界面的，那麼我們還可以用Invoke方法。

Invoke方法來操作界面

下面是一個例子：

using System; 

using System.Collections.Generic; 

using System.ComponentModel; 

using System.Data; 

using System.Drawing; 

using System.Linq; 

using System.Text; 

using System.Windows.Forms; 

using System.Threading; 

namespacepublicpartialclass//定義delegate以便Invoke時使用

privatedelegatevoid SetProgressBarValue(int value); 

public ThreadForm() 

{ 

InitializeComponent(); 

} 

privatevoid btnThread_Click(object sender, EventArgs e) 

{ 

progressBar.Value =0; 

//訓示是否對錯誤線程的調用，即是否允許在建立UI的線程之外通路線程 

//CheckForIllegalCrossThreadCalls = false;

Thread thread =new Thread(new ThreadStart(Run)); 

thread.Start(); 

} 

//使用線程來直接設定進度條

privatevoidwhile (progressBar.Value < progressBar.Maximum) 

{ 

progressBar.PerformStep(); 

} 

} 

privatevoid btnInvoke_Click(object sender, EventArgs e) 

{ 

progressBar.Value =0=new Thread(new ThreadStart(RunWithInvoke)); 

thread.Start(); 

} 

//使用Invoke方法來設定進度條

privatevoidint value = progressBar.Value; 

while (value<//如果是跨線程調用

ifthis.Invoke(new SetProgressBarValue(SetProgressValue), value++else=++//跟SetProgressBarValue委托相比對的方法

privatevoid SetProgressValue(int value) 

{ 

progressBar.Value =

這個方法的功能跟上面的操作是一樣的，隻不過不需要設定CheckForIllegalCrossThreadCalls屬性，而且還不會抛出異常，當然除了上面的方法之外，還可以使用BackgroundWorker類來完成同樣的功能。

BackgroundWorker類操作界面

因為使用BackgroundWorker類操作UI界面的例子周公部落格上已經有過例子，是以這裡的例子代碼注釋比較簡單，讀者可以看周公以前的示例，這次所使用的代碼示例如下：

using System; 

using System.Collections.Generic; 

using System.ComponentModel; 

using System.Data; 

using System.Drawing; 

using System.Linq; 

using System.Text; 

using System.Windows.Forms; 

using System.Threading; 

namespacepublicpartialclass//定義delegate以便Invoke時使用

privatedelegatevoid SetProgressBarValue(int value); 

private BackgroundWorker worker; 

public ThreadForm() 

{ 

InitializeComponent(); 

} 

privatevoid btnThread_Click(object sender, EventArgs e) 

{ 

progressBar.Value =0; 

//訓示是否對錯誤線程的調用，即是否允許在建立UI的線程之外通路線程 

//CheckForIllegalCrossThreadCalls = false;

Thread thread =new Thread(new ThreadStart(Run)); 

thread.Start(); 

} 

//使用線程來直接設定進度條

privatevoidwhile (progressBar.Value < progressBar.Maximum) 

{ 

progressBar.PerformStep(); 

} 

} 

privatevoid btnInvoke_Click(object sender, EventArgs e) 

{ 

progressBar.Value =0=new Thread(new ThreadStart(RunWithInvoke)); 

thread.Start(); 

} 

//使用Invoke方法來設定進度條

privatevoidint value = progressBar.Value; 

while (value<//如果是跨線程調用

ifthis.Invoke(new SetProgressBarValue(SetProgressValue), value++else=++//跟SetProgressBarValue委托相比對的方法

privatevoid SetProgressValue(int value) 

{ 

progressBar.Value =privatevoid btnBackgroundWorker_Click(object sender, EventArgs e) 

{ 

progressBar.Value =0=new BackgroundWorker(); 

worker.DoWork +=new DoWorkEventHandler(worker_DoWork); 

//當工作進度發生變化時執行的事件處理方法

worker.ProgressChanged +=new ProgressChangedEventHandler(worker_ProgressChanged); 

//當事件處理完畢後執行的方法

worker.RunWorkerCompleted +=new RunWorkerCompletedEventHandler(worker_RunWorkerCompleted); 

worker.WorkerReportsProgress =true;//支援報告進度更新

worker.WorkerSupportsCancellation =false;//不支援異步取消

worker.RunWorkerAsync();//啟動執行

btnBackgroundWorker.Enabled =false//當事件處理完畢後執行的方法

void worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) 

{ 

btnBackgroundWorker.Enabled=true//當工作進度發生變化時執行的事件處理方法

void worker_ProgressChanged(object sender, ProgressChangedEventArgs e) 

{ 

//可以在這個方法中與界面進行通訊

progressBar.Value =//開始啟動工作時執行的事件處理方法

void worker_DoWork(object sender, DoWorkEventArgs e) 

{ 

int value = progressBar.Value; 

while (value < progressBar.Maximum) 

{ 

worker.ReportProgress(++value);//彙報進度

當然，除了BackgroundWorker可以完成上面的功能之外，利用System.Windows.Forms.Timer類也能完場上面的功能，代碼如下： using System; 

using System.Collections.Generic; 

using System.ComponentModel; 

using System.Data; 

using System.Drawing; 

using System.Linq; 

using System.Text; 

using System.Windows.Forms; 

using System.Threading; 

namespacepublicpartialclass//定義delegate以便Invoke時使用

privatedelegatevoid SetProgressBarValue(int value); 

private BackgroundWorker worker; 

public ThreadForm() 

{ 

InitializeComponent(); 

} 

privatevoid btnThread_Click(object sender, EventArgs e) 

{ 

progressBar.Value =0; 

//訓示是否對錯誤線程的調用，即是否允許在建立UI的線程之外通路線程 

//CheckForIllegalCrossThreadCalls = false;

Thread thread =new Thread(new ThreadStart(Run)); 

thread.Start(); 

} 

//使用線程來直接設定進度條

privatevoidwhile (progressBar.Value < progressBar.Maximum) 

{ 

progressBar.PerformStep(); 

} 

} 

privatevoid btnInvoke_Click(object sender, EventArgs e) 

{ 

progressBar.Value =0=new Thread(new ThreadStart(RunWithInvoke)); 

thread.Start(); 

} 

//使用Invoke方法來設定進度條

privatevoidint value = progressBar.Value; 

while (value<//如果是跨線程調用

ifthis.Invoke(new SetProgressBarValue(SetProgressValue), value++else=++//跟SetProgressBarValue委托相比對的方法

privatevoid SetProgressValue(int value) 

{ 

progressBar.Value =privatevoid btnBackgroundWorker_Click(object sender, EventArgs e) 

{ 

progressBar.Value =0=new BackgroundWorker(); 

worker.DoWork +=new DoWorkEventHandler(worker_DoWork); 

//當工作進度發生變化時執行的事件處理方法

worker.ProgressChanged +=new ProgressChangedEventHandler(worker_ProgressChanged); 

//當事件處理完畢後執行的方法

worker.RunWorkerCompleted +=new RunWorkerCompletedEventHandler(worker_RunWorkerCompleted); 

worker.WorkerReportsProgress =true;//支援報告進度更新

worker.WorkerSupportsCancellation =false;//不支援異步取消

worker.RunWorkerAsync();//啟動執行

btnBackgroundWorker.Enabled =false//當事件處理完畢後執行的方法

void worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) 

{ 

btnBackgroundWorker.Enabled=true//當工作進度發生變化時執行的事件處理方法

void worker_ProgressChanged(object sender, ProgressChangedEventArgs e) 

{ 

//可以在這個方法中與界面進行通訊

progressBar.Value =//開始啟動工作時執行的事件處理方法

void worker_DoWork(object sender, DoWorkEventArgs e) 

{ 

int value = progressBar.Value; 

while (value < progressBar.Maximum) 

{ 

worker.ReportProgress(++value);//彙報進度

//使用System.Windows.Forms.Timer來操作界面能

privatevoid btnTimer_Click(object sender, EventArgs e) 

{ 

progressBar.Value =0; 

//注意在.net中有多個命名空間下存在Timer類，為了便于差別，使用了帶命名空間形式

System.Windows.Forms.Timer timer =new System.Windows.Forms.Timer(); 

timer.Interval =1+=new EventHandler(timer_Tick); 

timer.Enabled =true//Timer中要定期執行的方法

void timer_Tick(objectint value = progressBar.Value; 

if (value < progressBar.Maximum) 

{ 

progressBar.Value = value+100

總結：本篇主要講述了使用線程操作Windows應用程式界面的方法，這些方法在編寫多線程的UI程式時可以參考。

http://www.csharpwin.com/csharpspace/10234r1033.shtml 多線程和異步的一些看法（異步寫檔案）

- 張小魚 2010-10-22 09:40

本文章是小弟的處女文章.以前隻在園子裡看文章. 

正方開始 

在工作中有一個項目由于寫檔案操作比較頻繁 

以前用的是同步寫檔案方式,有人提出要多線程寫檔案. 

多線程寫檔案的任務分給别一個同僚， 

因别一個同僚對多線程方面不太熟 我給他提供了下面這種試 

//多線程操作同步寫檔案方法 public ThreadOperate() { Thread t = new Thread(new ThreadStart(ThreadProc)); t.Start(); } //同步寫檔案方法 public static void ThreadProc() { }

後來看了一些資料 http://dev.yesky.com/135/3030135.shtml(多核時代對并發程式設計的探索) 

總結了下面這句： 

線程: 需要作業系統投入CPU資源來運作和排程 

異步: 無須消耗CPU時間的操作 如 I/O操作不僅包括了直接的檔案、網絡的讀寫，還包括資料庫操作、Web Service、HttpRequest以及.net Remoting等跨程序的調用。 

目前還不能很确定 上面這句是否正确. 請指點. 

根據上面那句話我的想法改變了,我認為用異步寫檔案比多線程更合适于是用了下面方式

//異步寫檔案 public void WriteFile() { FileStream fs = new FileStream(@"C:\Test.txt", FileMode.Create, FileAccess.Write, FileShare.Write); byte[] buffer = new byte[100]; for (int i = 0; i < buffer.Length; i++) { buffer[i] = 2; } fs.BeginWrite(buffer, 0, buffer.Length, FileCallBack, fs); } static void FileCallBack(IAsyncResult asyncResult) { FileStream fs = asyncResult.AsyncState as FileStream; if (fs != null) { fs.EndWrite(asyncResult); fs.Close(); } }

來源：http://www.chenjiliang.com/Article/View.aspx?ArticleID=2295 C#異步多線程(通路主線程控件)

- 張小魚 2010-10-22 09:42

在多線程的情況下，其它線程無法直接調用到主線程上的控件，隻能通過代理來實作主線程上控件的調用。

1、定義委托

　　// 執行任務的委托聲明（解決長任務死假）

　　delegate void RunTaskDelegate(int seconds);

　　// 顯示進度條的委托聲明（跨線程調用控件）

　　delegate void ShowProgressDelegate(int totalStep, int currentStep);

2、定義方法

　　private void ShowProgress(int totalStep, int currentStep)

　　{

　　　　progressBar1.Maximum = totalStep;

　　　　progressBar1.Value = currentStep;

　　}

3、定義線程

　　private void RunTask(int seconds)

　　{

　　　　ShowProgressDelegate showProgress = new ShowProgressDelegate(ShowProgress);

　　　　for (int i = 0; i < seconds * 4; i++)

　　　　{

　　　　　　Thread.Sleep(250);

　　　　　　// 在基礎視窗上調用顯示進度條的委托

　　　　　　this.Invoke(showProgress, new object[] { seconds * 4, i + 1 });

　　　　}

　　}

4、執行

　　RunTaskDelegate runTask = new RunTaskDelegate(RunTask);

　　// 異步調用執行任務的委托

　　runTask.BeginInvoke(20, null, null); .Net多線程完美講解

- 張小魚 2010-10-22 09:47

怎樣建立一個線程 

我隻簡單列舉幾種常用的方法,詳細可參考.Net多線程總結(一) 

一）使用Thread類 

ThreadStart threadStart=new ThreadStart(Calculate);//通過ThreadStart委托告訴子線程講執行什麼方法,這裡執行一個計算圓周長的方法

Thread thread=new Thread(threadStart);

thread.Start(); //啟動新線程

public void Calculate(){

double Diameter=0.5;

Console.Write("The perimeter Of Circle with a Diameter of {0} is {1}"Diameter,Diameter*Math.PI);

}

二）使用Delegate.BeginInvoke 

delegate double CalculateMethod(double Diameter); //申明一個委托，表明需要在子線程上執行的方法的函數簽名

static CalculateMethod calcMethod = new CalculateMethod(Calculate);//把委托和具體的方法關聯起來

static void Main(string[] args)

{

//此處開始異步執行,并且可以給出一個回調函數(如果不需要執行什麼後續操作也可以不使用回調)

calcMethod.BeginInvoke(5, new AsyncCallback(TaskFinished), null);

Console.ReadLine();

}

//線程調用的函數,給出直徑作為參數,計算周長

public static double Calculate(double Diameter)

{

return Diameter * Math.PI;

}

//線程完成之後回調的函數

public static void TaskFinished(IAsyncResult result)

{

double re = 0;

re = calcMethod.EndInvoke(result);

Console.WriteLine(re);

}

三）使用ThreadPool.QueueworkItem 

WaitCallback w = new WaitCallback(Calculate);

//下面啟動四個線程,計算四個直徑下的圓周長

ThreadPool.QueueUserWorkItem(w, 1.0);

ThreadPool.QueueUserWorkItem(w, 2.0);

ThreadPool.QueueUserWorkItem(w, 3.0);

ThreadPool.QueueUserWorkItem(w, 4.0);

public static void Calculate(double Diameter)

{

return Diameter * Math.PI;

}

下面兩條來自于http://www.cnblogs.com/tonyman/archive/2007/09/13/891912.html

受托管的線程與 Windows線程

必 須要了解，執行.NET應用的線程實際上仍然是Windows線程。但是，當某個線程被CLR所知時，我們将它稱為受托管的線程。具體來說，由受托管的代 碼建立出來的線程就是受托管的線程。如果一個線程由非托管的代碼所建立，那麼它就是非托管的線程。不過，一旦該線程執行了受托管的代碼它就變成了受托管的 線程。 

一個受托管的線程和非托管的線程的差別在于，CLR将建立一個System.Threading.Thread類的執行個體來代表并操作前者。在内部實作中，CLR将一個包含了所有受托管線程的清單儲存在一個叫做ThreadStore地方。 

CLR確定每一個受托管的線程在任意時刻都在一個AppDomain中執行，但是這并不代表一個線程将永遠處在一個AppDomain中，它可以随着時間的推移轉到其他的AppDomain中。 

從安全的角度來看，一個受托管的線程的主使用者與底層的非托管線程中的Windows主使用者是無關的。

前台線程與背景線程

啟 動了多個線程的程式在關閉的時候卻出現了問題，如果程式退出的時候不關閉線程，那麼線程就會一直的存在，但是大多啟動的線程都是局部變量，不能一一的關 閉，如果調用Thread.CurrentThread.Abort()方法關閉主線程的話，就會出現ThreadAbortException 異常，是以這樣不行。

後來找到了這個辦法： Thread.IsBackground 設定線程為背景線程。

msdn對前台線程 和背景線程的解釋：托管線程或者是背景線程，或者是前台線程。背景線程不會使托管執行環境處于活動狀态，除此之外，背景線程與前台線程是一樣的。一旦所有 前台線程在托管程序（其中 .exe 檔案是托管程式集）中被停止，系統将停止所有背景線程并關閉。通過設定 Thread.IsBackground 屬性，可以将一個線程指定為背景線程或前台線程。例如，通過将 Thread.IsBackground 設定為 true，就可以将線程指定為背景線程。同樣，通過将 IsBackground 設定為 false，就可以将線程指定為前台線程。從非托管代碼進入托管執行環境的所有線程都被标記為背景線程。通過建立并啟動新的 Thread 對象而生成的所有線程都是前台線程。如果要建立希望用來偵聽某些活動（如套接字連接配接）的前台線程，則應将 Thread.IsBackground 設定為 true，以便程序可以終止。 

是以解決辦法就是在主線程初始化的時候，設定：Thread.CurrentThread.IsBackground = true; 

這樣，主線程就是背景線程，在關閉主程式的時候就會關閉主線程，進而關閉所有線程。但是這樣的話，就會強制關閉所有正在執行的線程，是以在關閉的時候要對線程工作的結果儲存。

經常看到名為BeginXXX和EndXXX的方法，他們是做什麼用的 

這是.net的一個異步方法名稱規範

.Net 在設計的時候為異步程式設計設計了一個異步程式設計模型（APM），這個模型不僅是使用.NET的開發人員使用，.Net内部也頻繁用到，比如所有的Stream 就有BeginRead，EndRead，Socket,WebRequet,SqlCommand都運用到了這個模式，一般來講，調用 BegionXXX的時候，一般會啟動一個異步過程去執行一個操作，EndEnvoke可以接收這個異步操作的傳回，當然如果異步操作在 EndEnvoke調用的時候還沒有執行完成，EndInvoke會一直等待異步操作完成或者逾時 

.Net的異步程式設計模型（APM）一般包含BeginXXX，EndXXX，IAsyncResult這三個元素，BeginXXX方法都要傳回一個IAsyncResult，而EndXXX都需要接收一個IAsyncResult作為參數，他們的函數簽名模式如下 

IAsyncResult BeginXXX(...);

<傳回類型> EndXXX(IAsyncResult ar)； 

BeginXXX 和EndXXX中的XXX，一般都對應一個同步的方法,比如FileStream的Read方法是一個同步方法，相應的 BeginRead(),EndRead()就是他的異步版本，HttpRequest有GetResponse來同步接收一個響應，也提供了 BeginGetResponse和EndGetResponse這個異步版本，而IAsynResult是二者聯系的紐帶，隻有把BeginXXX所返 回的IAsyncResult傳給對應的EndXXX，EndXXX才知道需要去接收哪個BeginXXX發起的異步操作的傳回值。

這個 模式在實際使用時稍顯繁瑣,雖然原則上我們可以随時調用EndInvoke來獲得傳回值,并且可以同步多個線程,但是大多數情況下當我們不需要同步很多線 程的時候使用回調是更好的選擇,在這種情況下三個元素中的IAsynResult就顯得多餘,我們一不需要用其中的線程完結标志來判斷線程是否成功完成 (回調的時候線程應該已經完成了),二不需要他來傳遞資料,因為資料可以寫在任何變量裡,并且回調時應該已經填充,是以可以看到微軟在新的.Net Framework中已經加強了對回調事件的支援,這總模型下,典型的回調程式應該這樣寫

a.DoWork+=new SomeEventHandler(Caculate);

a.CallBack+=new SomeEventHandler(callback);

a.Run();

（注： 我上面講的是普遍的用法，然而BeginXXX，EndXXX僅僅是一種模式，而對這個模式的實作完全取決于使用他的開發人員，具體實作的時候你可以使用 另外一個線程來實作異步，也可能使用硬體的支援來實作異步，甚至可能根本和異步沒有關系（盡管幾乎沒有人會這樣做）-----比如直接在Beginxxx 裡直接輸出一個"Helloworld"，如果是這種極端的情況，那麼上面說的一切都是廢話，是以上面的探讨并不涉及内部實作，隻是告訴大家微軟的模式， 和架構中對這個模式的經典實作） 

異步和多線程有什麼關聯 

有一句話總結的很好：多線程是實作異步的一種手段和工具 

我們通常把多線程和異步等同起來，實際是一種誤解，在實際實作的時候，異步有許多種實作方法，我們可以用程序來做異步，或者使用纖程，或者硬體的一些特性，比如在實作異步IO的時候,可以有下面兩個方案:

1)可以通過初始化一個子線程，然後在子線程裡進行IO，而讓主線程順利往下執行，當子線程執行完畢就回調

2)也可以根本不使用新線程，而使用硬體的支援（現在許多硬體都有自己的處理器），來實作完全的異步，這是我們隻需要将IO請求告知硬體驅動程式，然後迅速傳回，然後等着硬體IO就緒通知我們就可以了

實 際上DotNet Framework裡面就有這樣的例子，當我們使用檔案流的時候，如果制定檔案流屬性為同步，則使用BeginRead進行讀取時，就是用一個子線程來調 用同步的Read方法，而如果指定其為異步，則同樣操作時就使用了需要硬體和作業系統支援的所謂IOCP的機制

WinForm多線程程式設計篇

我的多線程WinForm程式老是抛出InvalidOperationException ，怎麼解決？ 

在WinForm中使用多線程時，常常遇到一個問題，當在子線程（非UI線程）中修改一個控件的值：比如修改進度條進度，時會抛出如下錯誤 

Cross-thread operation not valid: Control ‘XXX‘ accessed from a thread other than the thread it was created on. 

在 VS2005或者更高版本中，隻要不是在控件的建立線程（一般就是指UI主線程）上通路控件的屬性就會抛出這個錯誤，解決方法就是利用控件提供的 Invoke和BeginInvoke把調用封送回UI線程，也就是讓控件屬性修改在UI線程上執行，下面列出會報錯的代碼和他的修改版本 

ThreadStart threadStart=new ThreadStart(Calculate);//通過ThreadStart委托告訴子線程講執行什麼方法

Thread thread=new Thread(threadStart);

thread.Start();

public void Calculate(){

double Diameter=0.5;

double result=Diameter*Math.PI;

CalcFinished(result);//計算完成需要在一個文本框裡顯示

}

public void CalcFinished(double result){

this.TextBox1.Text=result.ToString();//會抛出錯誤

}

上面加粗的地方在debug的時候會報錯，最直接的修改方法是修改Calculate這個方法如下 

delegate void changeText(double result);

public void Calculate(){

double Diameter=0.5;

double result=Diameter*Math.PI;

this.BeginInvoke(new changeText(CalcFinished),t.Result);//計算完成需要在一個文本框裡顯示

} 

這樣就ok了，但是最漂亮的方法是不去修改Calculate，而去修改CalcFinished這個方法，因為程式裡調用這個方法的地方可能很多，由于加了是否需要封送的判斷,這樣修改還能提高非跨線程調用時的性能

delegate void changeText(double result);

public void CalcFinished(double result){

if(this.InvokeRequired){

this.BeginInvoke(new changeText(CalcFinished),t.Result);

}

else{

this.TextBox1.Text=result.ToString();

}

}

上面的做法用到了Control的一個屬性InvokeRequired（這個屬性是可以在其他線程裡通路的）,這個屬性表明調用是否來自另非UI線程,如果是,則使用BeginInvoke來調用這個函數,否則就直接調用,省去線程封送的過程

Invoke，BeginInvoke幹什麼用的，内部是怎麼實作的?

這兩個方法主要是讓給出的方法在控件建立的線程上執行

Invoke使用了Win32API的SendMessage,

UnsafeNativeMethods.PostMessage(new HandleRef(this, this.Handle), threadCallbackMessage, IntPtr.Zero, IntPtr.Zero);

BeginInvoke使用了Win32API的PostMessage

UnsafeNativeMethods.PostMessage(new HandleRef(this, this.Handle), threadCallbackMessage, IntPtr.Zero, IntPtr.Zero);

這兩個方法向UI線程的消息隊列中放入一個消息,當UI線程處理這個消息時,就會在自己的上下文中執行傳入的方法,換句話說凡是使用BeginInvoke和Invoke調用的線程都是在UI主線程中執行的,是以如果這些方法裡涉及一些靜态變量,不用考慮加鎖的問題

每個線程都有消息隊列嗎?

不是,隻有建立了窗體對象的線程才會有消息隊列(下面給出<Windows 核心程式設計>關于這一段的描述)

當 一個線程第一次被建立時，系統假定線程不會被用于任何與使用者相關的任務。這樣可以減少線程對系統資源的要求。但是，一旦這個線程調用一個與圖形使用者界面有 關的函數（例如檢查它的消息隊列或建立一個視窗），系統就會為該線程配置設定一些另外的資源，以便它能夠執行與使用者界面有關的任務。特别是，系統配置設定一個T H R E A D I N F O結構，并将這個資料結構與線程聯系起來。 

這個T H R E A D I N F O結構包含一組成員變量，利用這組成員，線程可以認為它是在自己獨占的環境中運作。T H R E A D I N F O是一個内部的、未公開的資料結構，用來指定線程的登記消息隊列（posted-message queue）、發送消息隊列（ send-message queue）、應答消息隊列（ r e p l y -message queue）、虛拟輸入隊列（virtualized-input queue）、喚醒标志（wake flag）、以及用來描述線程局部輸入狀态的若幹變量。圖2 6 - 1描述了T H R E A D I N F O結構和與之相聯系的三個線程。 

為什麼Winform不允許跨線程修改UI線程控件的值

在vs2003下,使用子線程調用ui線程建立的控件的屬性是不會有問題的,但是編譯的時候會出現警告,但是vs2005及以上版本就會有這樣的問題,下面是msdn上的描述 

" 當您在 Visual Studio 調試器中運作代碼時，如果您從一個線程通路某個 UI 元素，而該線程不是建立該 UI 元素時所在的線程，則會引發 InvalidOperationException。調試器引發該異常以警告您存在危險的程式設計操作。UI 元素不是線程安全的，是以隻應在建立它們的線程上進行通路" 

從上面可以看出,這個異常實際是debugger耍的花招,也就是說,如果 你直接運作程式的exe檔案,或者利用運作而不調試(Ctrl+F5)來運作你的程式,是不會抛出這樣的異常的.大概ms發現v2003的警告對廣大開發 者不起作用,是以用了一個比較狠一點的方法. 

不過問題依然存在:既然這樣設計的原因主要是因為控件的值非線程安全,那麼DotNet framework中非線程安全的類千千萬萬,為什麼偏偏跨線程修改Control的屬性會有這樣嚴格的限制政策呢? 

這個問題我還回答不好,希望博友們能夠予以補充 

有沒有什麼辦法可以簡化WinForm多線程的開發

使用backgroundworker,使用這個組建可以避免回調時的Invoke和BeginInvoke,并且提供了許多豐富的方法和事件

參見.Net多線程總結(二)-BackgroundWorker,我在這裡不再贅訴

線程池

線程池的作用是什麼 

作用是減小線程建立和銷毀的開銷 

建立線程涉及使用者模式和核心模式的切換，記憶體配置設定，dll通知等一系列過程，線程銷毀的步驟也是開銷很大的，是以如果應用程式使用了完一個線程，我們能把線程暫時存放起來，以備下次使用，就可以減小這些開銷 

所有程序使用一個共享的線程池,還是每個程序使用獨立的線程池? 

每 個程序都有一個線程池,一個Process中隻能有一個執行個體，它在各個應用程式域（AppDomain）是共享的，.Net2.0 中預設線程池的大小為工作線程25個,IO線程1000個,有一個比較普遍的誤解是線程池中會有1000個線程等着你去取,其實不然, ThreadPool僅僅保留相當少的線程，保留的線程可以用SetMinThread這個方法來設定，當程式的某個地方需要建立一個線程來完成工作時， 而線程池中又沒有空閑線程時,線程池就會負責建立這個線程,并且在調用完畢後,不會立刻銷毀,而是把他放在池子裡,預備下次使用,同時如果線程超過一定時 間沒有被使用,線程池将會回收線程，是以線程池裡存在的線程數實際是個動态的過程 

為什麼不要手動線程池設定最大值? 

當我首次看到線程池的時候,腦袋裡的第一個念頭就是給他設定一個最大值,然而當我們檢視ThreadPool的SetMaxThreads文檔時往往會看到一條警告:不要手動更改線程池的大小,這是為什麼呢? 

其 實無論FileStream的異步讀寫,異步發送接受Web請求,甚至使用delegate的beginInvoke都會預設調用 ThreadPool,也就是說不僅你的代碼可能使用到線程池,架構内部也可能使用到,更改的後果影響就非常大,特别在iis中,一個應用程式池中的所有 WebApplication會共享一個線程池，對最大值的設定會帶來很多意想不到的麻煩 

線程池的線程為何要分類? 

線 程池有一個方法可以讓我們看到線程池中可用的線程數量:GetAvaliableThread(out workerThreadCount,out iocompletedThreadCount),對于我來說,第一次看到這個函數的參數時十分困惑,因為我期望這個函數直接傳回一個整形,表明還剩多少 線程,這個函數居然一次傳回了兩個變量. 

原來線程池裡的線程按照公用被分成了兩大類:工作線程和IO線程,或者IO完成線程,前者用于 執行普通的操作,後者專用于異步IO,比如檔案和網絡請求,注意,分類并不說明兩種線程本身有差别,線程就是線程,是一種執行單元,從本質上來講都是一樣 的,線程池這樣分類,舉例來說,就好像某施工工地現在有1000把鐵鍬,規定其中25把給後勤部門用,其他都給施工部門,施工部門需要大量使用鐵鍬來挖地 基(例子土了點,不過說明問題還是有效的),後勤部門用鐵鍬也就是鏟鏟雪,鏟鏟垃圾,給勞工師傅修修臨時住房,是以用量不大，顯然兩個部門的鐵鍬本身沒有 差別，但是這樣的劃分就為管理兩個部門的鐵鍬提供了友善 

線程池中兩種線程分别在什麼情況下被使用,二者工作原理有什麼不同? 

下面這個例子直接說明了二者的差別,我們用一個流讀出一個很大的檔案(大一點操作的時間長,便于觀察),然後用另一個輸出流把所讀出的檔案的一部分寫到磁盤上 

我們用兩種方法建立輸出流,分别是 

建立了一個異步的流(注意構造函數最後那個true)

FileStream outputfs=new FileStream(writepath, FileMode.Create, FileAccess.Write, FileShare.None,256,true);

建立了一個同步的流 

FileStream outputfs = File.OpenWrite(writepath); 

然後在寫檔案期間檢視線程池的狀況

string readpath = "e:\\RHEL4-U4-i386-AS-disc1.iso";

string writepath = "e:\\kakakak.iso";

byte[] buffer = new byte[90000000];

//FileStream outputfs=new FileStream(writepath, FileMode.Create, FileAccess.Write, FileShare.None,256,true);

//Console.WriteLine("異步流");

//建立了一個同步的流

FileStream outputfs = File.OpenWrite(writepath);

Console.WriteLine("同步流");

//然後在寫檔案期間檢視線程池的狀況

ShowThreadDetail("初始狀态");

FileStream fs = File.OpenRead(readpath);

fs.BeginRead(buffer, 0, 90000000, delegate(IAsyncResult o)

{

outputfs.BeginWrite(buffer, 0, buffer.Length,

delegate(IAsyncResult o1)

{

Thread.Sleep(1000);

ShowThreadDetail("BeginWrite的回調線程");

}, null);

Thread.Sleep(500);//this is important cause without this, this Thread and the one used for BeginRead May seem to be same one

},

null);

Console.ReadLine();

public static void ShowThreadDetail(string caller)

{

int IO;

int Worker;

ThreadPool.GetAvailableThreads(out Worker, out IO);

Console.WriteLine("Worker: {0}; IO: {1}", Worker, IO);

}

輸出結果

異步流

Worker: 500; IO: 1000

Worker: 500; IO: 999

同步流

Worker: 500; IO: 1000

Worker: 499; IO: 1000

這兩個構造函數建立的流都可以使用BeginWrite來異步寫資料,但是二者行為不同,當使用同步的流進行異步寫時,通過回調的輸出我們可以看到,他使用的是工作線程,而非IO線程,而異步流使用了IO線程而非工作線程 

其 實當沒有制定異步屬性的時候,.Net實作異步IO是用一個子線程調用fs的同步Write方法來實作的,這時這個子線程會一直阻塞直到調用完成.這個子 線程其實就是線程池的一個工作線程,是以我們可以看到,同步流的異步寫回調中輸出的工作線程數少了一,而使用異步流,在進行異步寫時,采用了 IOCP方法,簡單說來,就是當BeginWrite執行時,把資訊傳給硬體驅動程式,然後立即往下執行(注意這裡沒有額外的線程),而當硬體準備就緒, 就會通知線程池,使用一個IO線程來讀取 

.Net線程池有什麼不足

沒有提供方法控制加入線程池的線程:一旦加入線程池,我們沒有辦法挂起,終止這些線程,唯一可以做的就是等他自己執行

1)不能為線程設定優先級

2) 一個Process中隻能有一個執行個體，它在各個AppDomain是共享的。ThreadPool隻提供了靜态方法，不僅我們自己添加進去的 WorkItem使用這個Pool，而且.net framework中那些BeginXXX、EndXXX之類的方法都會使用此Pool。 

3)所支援的Callback不能有傳回值。WaitCallback隻能帶一個object類型的參數，沒有任何傳回值。

4)不适合用在長期執行某任務的場合。我們常常需要做一個Service來提供不間斷的服務（除非伺服器down掉），但是使用ThreadPool并不合适。

下面是另外一個網友總結的什麼不需要使用線程池,我覺得挺好,引用下來

如果您需要使一個任務具有特定的優先級。 

如果您具有可能會長時間運作（并是以阻塞其他任務）的任務。 

如果您需要将線程放置到單線程單元中（所有 ThreadPool 線程均處于多線程單元中）。 

如果您需要與該線程關聯的穩定辨別。例如，您應使用一個專用線程來中止該線程、将其挂起或按名稱發現它。

鎖定與同步 

CLR怎樣實作lock(obj)鎖定? 

從原理上講,lock和Syncronized Attribute都是用Moniter.Enter實作的,比如如下代碼

object lockobj=new object();

lock(obj){ 

//do things 

}

在編譯時,會被編譯為類似 

try{

Moniter.Enter(obj){

//do things

}

}

catch{}

finally{

Moniter.Exit(obj);

}

而[MethodImpl(MethodImplOptions.Synchronized)]标記為同步的方法會在編譯時被lock(this)語句所環繞

是以我們隻簡單探讨Moniter.Enter的實作

（注:DotNet并非使用Win32API的CriticalSection來實作Moniter.Enter，不過他為托管對象提供了一個類似的結構叫做Syncblk） 

每 個對象執行個體頭部都有一個指針,這個指針指向的結構,包含了對象的鎖定資訊,當第一次使用Moniter.Enter(obj)時,這個obj對象的鎖定結 構就會被初時化,第二次調用Moniter.Enter時,會檢驗這個object的鎖定結構,如果鎖沒有被釋放,則調用會阻塞 

WaitHandle是什麼,他和他的派生類怎麼使用 

WaitHandle是Mutex，Semaphore，EventWaitHandler，AutoResetEvent，ManualResetEvent共同的祖先，他們包裝了用于同步的核心對象，也就是說是這些核心對象的托管版本。 

Mutex:類似于一個接力棒,拿到接力棒的線程才可以開始跑,當然接力棒一次隻屬于一個線程(Thread Affinity),如果這個線程不釋放接力棒(Mutex.ReleaseMutex),那麼沒辦法,其他所有需要接力棒運作的線程都知道能等着看熱鬧 

Semaphore: 類似于一個小桶,裡面裝了幾個小球,凡是拿到小球就可以跑,比如指定小桶裡最初有四個小球,那麼開始的四個線程就可以直接拿着自己的小球開跑,但是第五個 線程一看,小球被拿光了,就隻好乖乖的等着有誰放一個小球到小桶裡(Semophore.Release),他才能跑,但是這裡的遊戲規則比較特殊,我們 可以随意向小桶裡放入小球,也就是說我可以拿走一個小球,放回去倆,甚至一個都不拿,放回去5個,這樣就有五個線程可以拿着這些小球運作了.我們可以規定 小桶裡有開始有幾個小球(構造函數的第一個參數),也可以規定最多不能超過多少小球(構造函數的第二個參數) 

ManualResetEvent,AutoResetEvent可以參考http://www.cnblogs.com/uubox/archive/2007/12/18/1003953.html

什麼是用雙鎖實作Singleton,為什麼要這樣做,雙鎖檢驗是不安全的嗎? 

使用雙鎖檢驗技巧來實作單件,來自于Java社群

public static MySingleton Instance{

get{

if(_instance!=null)}{

lock(_instance){

if(s_value==null){

_instance= new MySingleton();

}

}

}

}

} 

這樣做其實是為了提高效率,比起 

public static MySingleton Instance{ 

get{ 

lock(_instance){ 

if(s_value==null){ 

_instance= new MySingleton(); 

} 

}

前一種方法在instance建立的時候不需要用lock同步,進而增進了效率

在java中這種技巧被證明是不安全的詳細見http://www.cs.umd.edu/~pugh/java/memoryModel/

但是在.Net下,這樣的技巧是成立的,因為.Net使用了改進的記憶體模型

并且在.Net下,我們可以使用LazyInit來實作單件

private static readonly _instance=new MySingleton()

public static MySingleton Instance{

get{return _instance}

}

當第一此使用_instance時,CLR會生成這個對象,以後再通路這個字段,将會直接傳回

互斥對象（Mutex）,信号量(Semaphore),事件（Event）對象與lock語句的比較 

首先這裡所謂的事件對象不是System.Event，而是一種用于同步的核心機制 

互斥對象和事件對象屬于核心對象，利用核心對象進行線程同步，線程必須要在使用者模式和核心模式間切換，是以一般效率很低，但利用互斥對象和事件對象這樣的核心對象，可以在多個程序中的各個線程間進行同步。 

lock或者Moniter是.net用一個特殊結構實作的,不涉及模式切換,也就是說工作在使用者方式下，同步速度較快,但是不能跨程序同步

什麼時候需要鎖定? 

剛剛接觸鎖定的程式員往往覺得這個世界非常的危險,每個靜态變量似乎都有可能産生競争 

首先鎖定是解決競争條件的,也就是多個線程同時通路某個資源,造成意想不到的結果,比如,最簡單的情況,一個計數器,如果兩個線程同時加一,後果就是損失了一個計數,但是頻繁的鎖定又可能帶來性能上的消耗,還有最可怕的情況,死鎖 

到底什麼情況下我們需要使用鎖,什麼情況下不用呢? 

隻有共享資源才需要鎖定

首先,隻有可以被多線程通路的共享資源才需要考慮鎖定,比如靜态變量,再比如某些緩存中的值,屬于線程内部的變量不需要鎖定 

把鎖定交給資料庫

資料庫除了存儲資料之外,還有一個重要的用途就是同步,資料庫本身用了一套複雜的機制來保證資料的可靠和一緻性,這就為我們節省了很多的精力.保證了資料源頭上的同步,我們多數的精力就可以集中在緩存等其他一些資源的同步通路上了 

了解你的程式是怎麼運作的

實 際上在web開發中大多數邏輯都是在單個線程中展開的,無論asp.net還是php,一個請求都會在一個單獨的線程中處理,其中的大部分變量都是屬于這 個線程的,根本沒有必要考慮鎖定,當然對于asp.net中的application對象中的資料,我們就要小心一些了

WinForm中凡是使用BeginInvoke和Invoke調用的方法也都不需要考慮同步,因為這用這兩個方法調用的方法會在UI線程中執行,是以實際是同步的,是以如果調用的方法中存在某些靜态變量,不需要考慮鎖定

業務邏輯對事務和線程安全的要求

這 條是最根本的東西,開發完全線程安全的程式是件很費時費力的事情,在電子商務等涉及金融系統的案例中,許多邏輯都必須嚴格的線程安全,是以我們不得不犧牲 一些性能,和很多的開發時間來做這方面的工作,而一般的應用中,許多情況下雖然程式有競争的危險,我們還是可以不使用鎖定,比如有的時候計數器少一多一, 對結果無傷大雅的情況下,我們就可以不用去管他 

計算一下沖突的可能性

我以前曾經談到過,架構不要過設計,其實在這裡也一樣,假 如你的全局緩存裡的某個值每天隻有幾百或者幾千個通路,并且通路時間很短,并且分布均勻(實際上這是大多數的情況),那麼沖突的可能性就非常的少,也許每 500天才會出現一次或者更長,從7*24小時安全服務的角度來看,也完全符合要求,那麼你還會為這樣萬分之一的可能性花80%的精力去設計嗎? 

請多使用lock,少用Mutex

如 果你一定要使用鎖定,請盡量不要使用核心子產品的鎖定機制,比如.net的 Mutex,Semaphore,AutoResetEvent,ManuResetEvent,使用這樣的機制涉及到了系統在使用者模式和核心模式間的切 換,是以性能差很多,但是他們的優點是可以跨程序同步線程,是以應該清楚的了解到他們的不同和适用範圍 

Web和IIS

應用程式池,WebApplication,和線程池之間有什麼關系

一個應用程式池是一個獨立的程序,擁有一個線程池,應用程式池中可以有多個WebApplication,每個運作在一個單獨的AppDomain中,這些WebApplication公用一個線程池

不同的AppDomain保證了每個WebApplication的靜态變量不會互相幹擾,不同的應用程式池保證了一個網站癱瘓,其他不同程序中的站點還能正常運作

下圖說明了他們的關系

Web頁面怎麼調用異步WebService

把Page的Async屬性設定為true,就可以調用異步的方法,但是這樣調用的效果可能并不如我們的相像,請參考Web中使用多線程來增強使用者體驗 .Net多線程總結(一)

- 張小魚 2010-10-22 09:48

.Net提供了許多多線程程式設計工具,可能是因為太多了,是以掌握起來總是有一些頭疼,我在這裡講講我總結的一些多線程程式設計的經驗,希望對大家有幫助

不需要傳遞參數,也不需要傳回參數

我們知道啟動一個線程最直覺的辦法是使用Thread類,具體步驟如下

ThreadStart threadStart=new ThreadStart(Calculate);

Thread thread=new Thread(threadStart);

thread.Start(); 

public void Calculate(){

double Diameter=0.5;

Console.Write("The perimeter Of Circle with a Diameter of {0} is {1}"Diameter,Diameter*Math.PI);

} 

例1 

上 面我們用定義了一個ThreadStart類型的委托,這個委托制定了線程需要執行的方法:Calculate,在這個方法裡計算了一個直徑為0.5的圓 的周長,并輸出.這就構成了最簡單的多線程的例子,在很多情況下這就夠用了,然後ThreadStart這個委托定義為void ThreadStart(),也就是說,所執行的方法不能有參數,這顯然是個很大的不足,為了彌補這個缺陷,聰明的程式員想出了許多好的方法,我們将在需 要傳遞多個參數一節中進行介紹,這裡我們先介紹.Net為了解決這個問題而設定的另外一個委托:就是ParameterizedThreadStart ,我會在下面詳細講述 

需要傳遞單個參數

ParameterThreadStart的定義為void ParameterizedThreadStart(object state)??使用這個這個委托定義的線程的啟動函數可以接受一個輸入參數,具體例子如下

ParameterizedThreadStart threadStart=new ParameterizedThreadStart(Calculate)

Thread thread=new Thread()

thread.Start(0.9); 

public void Calculate(object arg){

double Diameter=double(arg);

Console.Write("The perimeter Of Circle with a Diameter of {0} is {1}"Diameter,Diameter*Math.PI);

}

例2

Calculate方法有一個為object類型的參數,雖然隻有一個參數,而且還是object類型的,使用的時候尚需要類型轉換,但是好在可以有參數了,并且通過把多個參數組合到一個類中,然後把這個類的執行個體作為參數傳遞,就可以實作多個參數傳遞

需要傳遞多個參數

雖然通過把需要的參數包裝到一個類中,委托ParameterizedThreadStart就可以傳遞多個參數,但是由于這個委托的傳入參數是object,是以不可避免的需要進行參數轉換,下面還有幾個常用的參數傳遞方法,讓我們來一一看來

使用專門的線程類

這 是許多程式員愛使用的經典模式,簡單來說,就是把需要另起線程執行的方法,和他需要的參數放到一個類中,參數作為了類的屬性,調用時聲明此類的執行個體,然後 初始化屬性,方法執行時直接使用類裡初始化好的屬性來執行,這樣方法本身就可以不需要參數,而又起到了多參數傳遞的效果,于是使用本文最開始提到的不帶參 數的ThreadStart委托就可以了,并且由于需要執行的方法和參數都放在一個類中,充分展現了面向對象的特點.具體方法如下 

還是計算面積的方法的例子,我們把這個方法用一個類包裝起來,輸入參數Diameter(直徑)是這個類的一個字段

public class MyThread

{

public double Diameter=10; 

public double Result=0; 

public MyThread(int Diameter)

{

this.Diameter = Diameter;

} 

public void Calculate()

{

Console.WriteLine( "Calculate Start");

Thread.Sleep(2000);

Result = Diameter*Math.PI;;

Console.WriteLine("Calculate End, Diameter is {0},Result is {1}" ,this.Diameter, Result);

}

}

MyThread t=new MyThread(5.0);

ThreadStart threadStart=new ThreadStart(t.Calculate)

Thread thread=new Thread(threadStart);

thread.Start(); 

例3

這種方法把參數傳遞變成了屬性共享,想傳遞多少個變量都可以,從封裝上講,把邏輯和邏輯涉及的資料封裝在一起,也很不錯,這個方法還有一個聰明的變體,利用了匿名方法,這種變體連獨立的類都省掉了,我現在給出這個方法

double Diameter = 6;

double Result=0;

Thread ta = new Thread(new ThreadStart(delegate()

{

Thread.Sleep(2000);

Result=Diameter * Math.PI;

Console.WriteLine("匿名 Calculate End, Diameter is {0},Result is {1}", Diameter, Result); ;

})); 

ta.Start();

例4 

這 個方法和上例道理相同,都是把參數傳遞變成了對變量的調用,進而取消了參數傳遞,但是,後者充分利用了匿名方法的一個性質,就是可以直接使用目前上下文的 局部變量,比如委托中的Diameter,和Result.當然,這樣做的缺點是如果匿名方法太長,程式的可讀性會降低,是以一般很少有人這樣做,這裡給 出這個方法供大家參考,關于匿名委托的資料可以參見 

聰明的讀者肯定想,既然可以用字段來傳入變量,當然也可以用字段傳出變量,比如在上面兩個例子裡我們看到計算結果都寫進了一個叫Result(加亮的地方)的變量裡,我們直接通路這個變量不就可以得到計算結果了嗎? 

這樣做有一個緻命的問題:既然是異步執行,主線程怎麼知道分線程什麼時候完成了計算呢?比如上兩個例子中,我們的線程都睡眠了2000毫秒,然後才進行計算,那麼如果主線程在沒有完成計算前通路Result,隻能得到一個0值.于是我們就有了下面的一系列解決方法. 

需要傳遞參數且需要傳回參數 

剛才說到主線程需要知道子線程什麼時候執行完成,可以使用Thread.ThreadState枚舉來判斷

當 線程的ThreadState==ThreadState.Stop時,一般就說明線程完成了工作,這時結果就可用了,如果不是這個狀态,就繼續執行别的 工作,或者等待一會,然後再嘗試.倘若需要等有多個子線程需的傳回,并且需要用他們的結果來進行進異步計算,那就叫做線程同步了,下面我們介紹另外一種我 比較推薦的方法,能夠自定義參數個數,并且傳回資料,而且使用起來也相對友善

使用委托的異步調用方法和回調

首先我們要把需要異步調用的方法定義為一個委托,然後利用BeginInvoke來異步調用,BeginInvoke的第一個參數就是直徑,第二個是當線程執行完畢後的調用的方法

delegate double CalculateMethod(double Diameter); 

static CalculateMethod calcMethod;

double result = 0; 

static void Main(string[] args)

{ 

calcMethod = new CalculateMethod(Calculate);

calcMethod.BeginInvoke(5, new AsyncCallback(TaskFinished), null); 

} 

///<summary>

///線程調用的函數

///<summary> 

public static double Calculate(double Diameter)

{

return Diameter * Math.PI;

} 

///<summary>

///線程完成之後回調的函數

///<summary>

public static void TaskFinished(IAsyncResult result)

{

result=calcMethod.EndInvoke(result);

}

例5 

注意,再線程執行完畢後執行的方法TaskFinished中,我們使用了EndInvoke來取得這個函數的傳回值

線程池

線程雖然是個好東西,但是也是個資源消耗大戶,許多時候,我們需要用多線程,但是又不希望線程的數量過多,這就是線程池的作用,.Net為我們提供了現成的線程池ThreadPool,他的使用如下

WaitCallback w = new WaitCallback(Calculate);

ThreadPool.QueueUserWorkItem(w, 1.0);

ThreadPool.QueueUserWorkItem(w, 2.0);

ThreadPool.QueueUserWorkItem(w, 3.0);

ThreadPool.QueueUserWorkItem(w, 4.0);

public static void Calculate(double Diameter)

{

return Diameter * Math.PI;

} 

例6

首 先定義一個WaitCallback委托,WaitCallback的格式是void WaitCallback(object state),也就是說你的方法必須符合這個格式,接着調用QueueUserWorkItem,将這個任務加入線程池,當縣城池有空閑線時,将會排程并 運作你的代碼

每一個程序都有一個線程池,線程池的預設大小是25,我們可以通過SetMaxThreads方法來設定其最大值.

[注]由于每個程序隻有一個線程池,是以如果是在iis程序,或者sqlserver的程序中使用線程池,并且需要設定線程池的最大容量的話,會影響到iis程序或sql程序,是以這兩種情況下要特别小心

控制權 

在 和大家交談的時候我發現凡是習慣了面向對象思維的同僚,總是對多線程情況下的執行上下文很困擾,比如例5中,主程式啟動了子線程執行Calculate方 法,執行完畢後回調TaskFinished,假如主線程id是1,子線程id是2,那麼Calculate肯定是在id=2的線程中執行,那麼他的回調 函數TaskFinished呢? 同樣也是在id=2的線程上下文中執行,不信你輸出線程id試試,這通常不是什麼問題,但是當我們需要在Winform程式設計中使用子線程時,就有可能會引 起問題了,我們将在下面講這個問題 

窗體程式多線程程式設計的特殊性 

當我們把例5的回調代碼稍加修改,搬到winform裡面,就可以看到問題所在了

public static void TaskFinished(IAsyncResult result)

{

result=calcMethod.EndInvoke(result);

this.TextBox1.Text=result;

}

程 序的原意是線上程執行完畢後講結果寫入一個TextBox,然而當程式執行到this.TextBox1.Text=result這裡的時候就抱錯了.原 來WinForm對線程有很嚴格的要求,除了建立這些控件的線程,其他線程想跨線程通路WinForm上的控件的屬性和方法是不允許(除了幾個特殊屬 性),在有的版本系統上,比如XP,對這個問題進行了處理,跨線程控件通路可以被執行,但是大多數windows系統都是不可以的,那麼如果我們确實需要 跨線程修改控件屬性,或者調用控件的方法,就必須用到控件的一個方法Invoke,這個方法可以把執行上下文切換回建立這些控件的線程,具體操作如下

delegate void changeText(string result);

public static void TaskFinished(IAsyncResult result)

{

result=calcMethod.EndInvoke(result); 

this.BeginInvoke(new changeText(this.textBox1.AppendText),t.Result.ToString())

}

由于委托中必須使用方法,是以我用AppendTex方法t,而不是直接設定Text屬性,你如果想設定text屬性,就必須自己包裝一個方法,然後連接配接到委托了