ホームページ >バックエンド開発 >C#.Net チュートリアル >C# の包括的な秘密 - マルチスレッドの詳細
C# の包括的な秘密 - マルチスレッドの詳細
- 高洛峰オリジナル
- 2016-12-12 15:06:311155ブラウズ
この記事では、スレッドの基本的な使い方からマルチスレッドの開発、CLRスレッドプールのワーカースレッドやI/Oスレッドの開発、PLINQの並列動作を中心に紹介します。
その中で、委任された BeginInvoke メソッドとコールバック関数が最もよく使用されます。
I/O スレッドは誰でも簡単に無視されるかもしれません。実際、マルチスレッド システムを開発するときは、I/O スレッドの動作にもっと注意を払う必要があります。特に ASP.NET 開発では、クライアント側で Ajax を使用するか、サーバー側で UpdatePanel を使用するかのみに注目する人が増えるかもしれません。実際、I/O スレッドを合理的に使用すると、プロジェクトの通信やファイルのダウンロード時の IIS への負担を可能な限り軽減できます。
並列プログラミングは、Framework 4.0 で強力に推進されている非同期操作手法であり、より深く学ぶ価値があります。
この記事があなたの学習や研究に役立つことを願っています。間違いや脱落があればコメントしてください。
1. スレッドの定義
1. 1 プロセス、アプリケーションドメイン、スレッドの関係
プロセスは、プログラムを実行するために必要なリソースを含む Windows システムの基本概念です。プロセスは比較的独立しています。あるプロセスが別のプロセスのデータにアクセスすることはできません (分散コンピューティングが使用されていない限り)。Windows システムは、プロセスを使用して作業を複数のプロセスに分割します。独立した地域。プロセスは、プログラムの基本的な境界として理解できます。
アプリケーション ドメイン (AppDomain) は、プログラムが実行される論理領域であり、アプリケーション ドメイン内で実行される軽量のプロセスとみなすことができます。また、アプリケーション ドメインにも複数のアプリケーションを含めることができます。複数のアセンブリが含まれています。アプリケーション ドメインには 1 つ以上のコンテキストが含まれており、コンテキスト CLR を使用して、特定の特別なオブジェクトの状態をさまざまなコンテナーに配置できます。
スレッドはプロセス内の基本的な実行単位であり、プロセスのエントリで実行される最初のスレッドがプロセスのメインスレッドとみなされます。 .NET アプリケーションでは、Main() メソッドがエントリ ポイントとして使用され、このメソッドが呼び出されると、システムはメイン スレッドを自動的に作成します。スレッドは主に、CPU レジスタ、コール スタック、スレッド ローカル ストレージ (スレッド ローカル ストレージ、TLS) で構成されます。 CPU レジスタは主に現在実行中のスレッドのステータスを記録し、コール スタックは主にスレッドによって呼び出されるメモリとデータを維持するために使用され、TLS は主にスレッドのステータス情報を保存するために使用されます。
プロセス、アプリケーション ドメイン、スレッドの関係は次のとおりです。プロセスには複数のアプリケーション ドメインと複数のスレッドを含めることができ、スレッドは複数のアプリケーション ドメイン間を行き来することもできます。しかし同時に、スレッドは 1 つのアプリケーション ドメイン内にのみ存在します。
1.2 マルチスレッド
シングル CPU システムの単位時間 (タイム スライス) 内で、CPU は 1 つのスレッドのみを実行でき、実行順序はスレッドの優先順位によって決まります。スレッドが単位時間内に実行を完了できなかった場合、システムはスレッドのステータス情報をスレッドのローカル ストレージ (TLS) に保存して、次回実行を再開できるようにします。マルチスレッドはシステムによってもたらされる単なる幻想であり、複数の時間単位で複数のスレッドを切り替えます。切り替えが頻繁で単位時間が非常に短いため、複数のスレッドが同時に実行されているとみなすことができます。
マルチスレッドを適切に使用すると、システムのパフォーマンスを向上させることができます。たとえば、システムが大容量のデータを要求する場合はマルチスレッドを使用し、データ出力作業を非同期スレッドに引き渡して、メインスレッドが維持できるようにします。他の問題を処理できる安定性。ただし、注意すべき点は、CPU はスレッドの切り替えに多くの時間を費やす必要があるため、マルチスレッドを過度に使用するとパフォーマンスの低下につながることです。
2. スレッドの基礎知識
2.1 System.Threading.Thread クラス
System.Threading.Thread は、現在のアプリケーション ドメイン内のスレッドの作成、一時停止、停止を制御することができます。 。 、破壊する。
次の共通のパブリック プロパティが含まれます:
2.1.1 スレッド識別子
ManagedThreadId は、確認されたスレッドの一意の識別子です。ほとんどの場合、プログラムは Thread.ManagedThreadId を通じてスレッドを識別します。 Name は変数値です。デフォルトでは、開発者はプログラムを通じてスレッドの名前を設定できますが、これは単なる補助機能です。
2.1.2 スレッドの優先度レベル
.NET は、スレッド実行の優先度レベルを定義するためにスレッドの Priority 属性を設定します。これには 5 つのオプションが含まれており、そのうちのデフォルト値は Normal です。システムに特別な要件がない限り、スレッドの優先順位をむやみに設定すべきではありません。
2.1.3 スレッドステータス
ThreadState は、スレッドが未起動、スリープ、実行中などにあるかどうかを検出するために使用でき、IsAlive 属性よりも具体的な情報を提供できます。
前述したように、アプリケーション ドメインには複数のコンテキストが含まれる場合があり、スレッドの現在のコンテキストは CurrentContext を通じて取得できます。
CurrentThread は最も一般的に使用される属性で、現在実行中のスレッドを取得するために使用されます。
2.1.4 System.Threading.Thread のメソッド
Thread には、スレッドの作成、一時停止、停止、破棄を制御する複数のメソッドが含まれており、これらは今後の例で頻繁に使用されます。
2.1.5 開発例
次の例は、Thread を通じて現在のスレッド情報を表示するものです
static void Main(string[] args)
{
Thread thread = Thread.CurrentThread;
thread.Name = "Main Thread";
string threadMessage = string.Format("Thread ID:{0}\n Current AppDomainId:{1}\n "+
"Current ContextId:{2}\n Thread Name:{3}\n "+
"Thread State:{4}\n Thread Priority:{5}\n",
thread.ManagedThreadId, Thread.GetDomainID(), Thread.CurrentContext.ContextID,
thread.Name, thread.ThreadState, thread.Priority);
Console.WriteLine(threadMessage);
Console.ReadKey();
}実行結果
2.2 System.Threading 名前空間
System.Threading 名前空間で複数の関数を提供しますマルチスレッド アプリケーションを構築するにはいくつかの方法がありますが、その中で、ThreadPool と Thread がマルチスレッド開発で最もよく使用されます。CLR スレッド プールは、スレッドの実行を管理するために特別に設定されます。 ThreadPoolクラスを使用して管理します。スレッドはスレッドを管理する最も直接的な方法です。次のセクションでは、関連するコンテンツを詳しく紹介します。
System.Threading には、以下の表に示す複数の一般的なデリゲートが含まれており、その中で最もよく使用されるデリゲートは ThreadStart と ParameterizedThreadStart です。
ThreadStart によって生成されたスレッドは最も直接的な方法ですが、ThreadStart によって生成されたスレッドはスレッド プールによって管理されません。
ParameterizedThreadStart は、パラメーターを使用してメソッドを非同期的にトリガーするように設計されています。これについては、次のセクションで詳しく説明します。
2.3 スレッド管理方法
ThreadStart を使用して新しいスレッドを作成するのが最も直接的な方法ですが、この方法で作成されたスレッドは管理が難しく、あまりにも多くのスレッドが作成されるとシステムのパフォーマンスが低下します。 。これを考慮して、.NET はスレッド管理のために CLR スレッド プールを特別に設定しており、CLR スレッド プール システムを使用すると、スレッドの使用をより合理的に管理できます。要求されたすべてのサービスはスレッド プール内で実行でき、操作が完了するとスレッドはスレッド プールに戻ります。設定により、スレッド プールの最大スレッド数を制御でき、リクエストが最大スレッド数を超えた場合、スレッド プールはオペレーションの優先レベルに従って実行され、一部のオペレーションは待機状態のままになります。スレッドが戻ったときに操作を実行します。
ここでは基礎知識を紹介します。以下ではマルチスレッドの開発について詳しく紹介します。
3. ThreadStart を使用してマルチスレッドを実装する
3.1 ThreadStart デリゲートを使用する
まず、現在実行中のスレッドを表示するメソッド ShowMessage() を Message クラスに作成します。 .Id を取得し、Thread.Sleep(int) メソッドを使用して作業の一部をシミュレートします。 main() で、ThreadStart デリゲートを介して Message オブジェクトの ShowMessage() メソッドをバインドし、Thread.Start() を介して非同期メソッドを実行します。
public class Message
{
public void ShowMessage()
{
string message = string.Format("Async threadId is :{0}",
Thread.CurrentThread.ManagedThreadId);
Console.WriteLine(message);
for (int n = 0; n < 10; n++)
{
Thread.Sleep(300);
Console.WriteLine("The number is:" + n.ToString());
}
}
}
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Main threadId is:"+
Thread.CurrentThread.ManagedThreadId);
Message message=new Message();
Thread thread = new Thread(new ThreadStart(message.ShowMessage));
thread.Start();
Console.WriteLine("Do something ..........!");
Console.WriteLine("Main thread working is complete!");
}
}Thread.Start() メソッドを呼び出した後、メインスレッドの動作が完了する前に、システムは Message.ShowMessage() を実行します。 ()、メインスレッド すべての操作が完了しました。
3.2 ParameterizedThreadStart デリゲートの使用
ParameterizedThreadStart デリゲートは ThreadStart デリゲートとよく似ていますが、ParameterizedThreadStart デリゲートはパラメーターを持つメソッド用です。 ParameterizedThreadStart の対応するメソッドのパラメータはオブジェクトであることに注意してください。このパラメータは値オブジェクトまたはカスタム オブジェクトである可能性があります。
public class Person
{
public string Name
{
get;
set;
}
public int Age
{
get;
set;
}
}
public class Message
{
public void ShowMessage(object person)
{
if (person != null)
{
Person _person = (Person)person;
string message = string.Format("\n{0}'s age is {1}!\nAsync threadId is:{2}",
_person.Name,_person.Age,Thread.CurrentThread.ManagedThreadId);
Console.WriteLine(message);
}
for (int n = 0; n < 10; n++)
{
Thread.Sleep(300);
Console.WriteLine("The number is:" + n.ToString());
}
}
}
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Main threadId is:"+Thread.CurrentThread.ManagedThreadId);
Message message=new Message();
//绑定带参数的异步方法
Thread thread = new Thread(new ParameterizedThreadStart(message.ShowMessage));
Person person = new Person();
person.Name = "Jack";
person.Age = 21;
thread.Start(person); //启动异步线程
Console.WriteLine("Do something ..........!");
Console.WriteLine("Main thread working is complete!");
}
}
実行結果:
3.3 フォアグラウンド スレッドとバックグラウンド スレッド
上記 2 つの例では Console.ReadKey() を使用していませんが、システムは非同期スレッドが完了するまで待機することに注意してください。 。これは、Thread.Start() を使用して開始されたスレッドはデフォルトでフォアグラウンド スレッドになり、システムはアプリケーション ドメインが自動的にアンロードされる前に、すべてのフォアグラウンド スレッドの実行が終了するまで待機する必要があるためです。
2 番目のセクションでは、Thread に IsBackground プロパティがあることを紹介しました。このプロパティを true に設定すると、スレッドをバックグラウンド スレッドとして設定できます。このとき、アプリケーション ドメインは、非同期スレッドの実行を待たずに、メイン スレッドの完了時にアンロードされます。
3.4 スレッドの一時停止
メインスレッドを終了する前に他のバックグラウンドスレッドが完了するのを待つために、Thread.Sleep() メソッドを使用できます。
public class Message
{
public void ShowMessage()
{
string message = string.Format("\nAsync threadId is:{0}",
Thread.CurrentThread.ManagedThreadId);
Console.WriteLine(message);
for (int n = 0; n < 10; n++)
{
Thread.Sleep(300);
Console.WriteLine("The number is:" + n.ToString());
}
}
}
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Main threadId is:"+
Thread.CurrentThread.ManagedThreadId);
Message message=new Message();
Thread thread = new Thread(new ThreadStart(message.ShowMessage));
thread.IsBackground = true;
thread.Start();
Console.WriteLine("Do something ..........!");
Console.WriteLine("Main thread working is complete!");
Console.WriteLine("Main thread sleep!");
Thread.Sleep(5000);
}
}実行結果は以下の通りです
但系统无法预知异步线程需要运行的时间，所以用通过Thread.Sleep（int）阻塞主线程并不是一个好的解决方法。有见及此，.NET专门为等待异步线程完成开发了另一个方法thread.Join()。把上面例子中的最后一行Thread.Sleep（5000）修改为 thread.Join() 就能保证主线程在异步线程thread运行结束后才会终止。
3.5 Suspend 与 Resume （慎用）
Thread.Suspend（）与 Thread.Resume（）是在Framework1.0 就已经存在的老方法了，它们分别可以挂起、恢复线程。但在Framework2.0中就已经明确排斥这两个方法。这是因为一旦某个线程占用了已有的资源，再使用Suspend（）使线程长期处于挂起状态，当在其他线程调用这些资源的时候就会引起死锁！所以在没有必要的情况下应该避免使用这两个方法。
3.6 终止线程
若想终止正在运行的线程，可以使用Abort（）方法。在使用Abort（）的时候，将引发一个特殊异常 ThreadAbortException 。
若想在线程终止前恢复线程的执行，可以在捕获异常后 ,在catch（ThreadAbortException ex）{...} 中调用Thread.ResetAbort（）取消终止。
而使用Thread.Join（）可以保证应用程序域等待异步线程结束后才终止运行。
static void Main(string[] args)
{
Console.WriteLine("Main threadId is:" +
Thread.CurrentThread.ManagedThreadId);
Thread thread = new Thread(new ThreadStart(AsyncThread));
thread.IsBackground = true;
thread.Start();
thread.Join();
}
//以异步方式调用
static void AsyncThread()
{
try
{
string message = string.Format("\nAsync threadId is:{0}",
Thread.CurrentThread.ManagedThreadId);
Console.WriteLine(message);
for (int n = 0; n < 10; n++)
{
//当n等于4时，终止线程
if (n >= 4)
{
Thread.CurrentThread.Abort(n);
}
Thread.Sleep(300);
Console.WriteLine("The number is:" + n.ToString());
}
}
catch (ThreadAbortException ex)
{
//输出终止线程时n的值
if (ex.ExceptionState != null)
Console.WriteLine(string.Format("Thread abort when the number is: {0}!",
ex.ExceptionState.ToString()));
//取消终止，继续执行线程
Thread.ResetAbort();
Console.WriteLine("Thread ResetAbort!");
}
//线程结束
Console.WriteLine("Thread Close!");
}运行结果如下
四、CLR线程池的工作者线程
4.1 关于CLR线程池
使用ThreadStart与ParameterizedThreadStart建立新线程非常简单，但通过此方法建立的线程难于管理，若建立过多的线程反而会影响系统的性能。
有见及此，.NET引入CLR线程池这个概念。CLR线程池并不会在CLR初始化的时候立刻建立线程，而是在应用程序要创建线程来执行任务时，线程池才初始化一个线程。线程的初始化与其他的线程一样。在完成任务以后，该线程不会自行销毁，而是以挂起的状态返回到线程池。直到应用程序再次向线程池发出请求时，线程池里挂起的线程就会再度激活执行任务。这样既节省了建立线程所造成的性能损耗，也可以让多个任务反复重用同一线程，从而在应用程序生存期内节约大量开销。
注意：通过CLR线程池所建立的线程总是默认为后台线程，优先级数为ThreadPriority.Normal。
4.2 工作者线程与I/O线程
CLR线程池分为工作者线程（workerThreads）与I/O线程 (completionPortThreads) 两种，工作者线程是主要用作管理CLR内部对象的运作，I/O（Input/Output) 线程顾名思义是用于与外部系统交换信息，IO线程的细节将在下一节详细说明。
通过ThreadPool.GetMax（out int workerThreads,out int completionPortThreads )和 ThreadPool.SetMax( int workerThreads, int completionPortThreads)两个方法可以分别读取和设置CLR线程池中工作者线程与I/O线程的最大线程数。在Framework2.0中最大线程默认为25*CPU数，在Framewok3.0、4.0中最大线程数默认为250*CPU数，在近年 I3,I5,I7 CPU出现后，线程池的最大值一般默认为1000、2000。
若想测试线程池中有多少的线程正在投入使用，可以通过ThreadPool.GetAvailableThreads( out intworkerThreads,out int completionPortThreads ) 方法。
使用CLR线程池的工作者线程一般有两种方式，一是直接通过 ThreadPool.QueueUserWorkItem() 方法，二是通过委托，下面将逐一细说。
4.3 通过QueueUserWorkItem启动工作者线程
ThreadPool线程池中包含有两个静态方法可以直接启动工作者线程：
一为 ThreadPool.QueueUserWorkItem(WaitCallback)
二为 ThreadPool.QueueUserWorkItem(WaitCallback,Object)
先把WaitCallback委托指向一个带有Object参数的无返回值方法，再使用 ThreadPool.QueueUserWorkItem(WaitCallback) 就可以异步启动此方法，此时异步方法的参数被视为null 。
class Program
{
static void Main(string[] args)
{
//把CLR线程池的最大值设置为1000
ThreadPool.SetMaxThreads(1000, 1000);
//显示主线程启动时线程池信息
ThreadMessage("Start");
//启动工作者线程
ThreadPool.QueueUserWorkItem(new WaitCallback(AsyncCallback));
Console.ReadKey();
}
static void AsyncCallback(object state)
{
Thread.Sleep(200);
ThreadMessage("AsyncCallback");
Console.WriteLine("Async thread do work!");
}
//显示线程现状
static void ThreadMessage(string data)
{
string message = string.Format("{0}\n CurrentThreadId is {1}",
data, Thread.CurrentThread.ManagedThreadId);
Console.WriteLine(message);
}
}运行结果
使用 ThreadPool.QueueUserWorkItem(WaitCallback,Object) 方法可以把object对象作为参数传送到回调函数中。
下面例子中就是把一个string对象作为参数发送到回调函数当中。
class Program
{
static void Main(string[] args)
{
//把线程池的最大值设置为1000
ThreadPool.SetMaxThreads(1000, 1000);
ThreadMessage("Start");
ThreadPool.QueueUserWorkItem(new WaitCallback(AsyncCallback),"Hello Elva");
Console.ReadKey();
}
static void AsyncCallback(object state)
{
Thread.Sleep(200);
ThreadMessage("AsyncCallback");
string data = (string)state;
Console.WriteLine("Async thread do work!\n"+data);
}
//显示线程现状
static void ThreadMessage(string data)
{
string message = string.Format("{0}\n CurrentThreadId is {1}",
data, Thread.CurrentThread.ManagedThreadId);
Console.WriteLine(message);
}
}运行结果
通过ThreadPool.QueueUserWorkItem启动工作者线程虽然是方便，但WaitCallback委托指向的必须是一个带有Object参数的无返回值方法，这无疑是一种限制。若方法需要有返回值，或者带有多个参数，这将多费周折。有见及此，.NET提供了另一种方式去建立工作者线程，那就是委托。
4.4 委托类
使用CLR线程池中的工作者线程，最灵活最常用的方式就是使用委托的异步方法，在此先简单介绍一下委托类。
当定义委托后，.NET就会自动创建一个代表该委托的类，下面可以用反射方式显示委托类的方法成员（对反射有兴趣的朋友可以先参考一下“.NET基础篇——反射的奥妙”）
class Program
{
delegate void MyDelegate();
static void Main(string[] args)
{
MyDelegate delegate1 = new MyDelegate(AsyncThread);
//显示委托类的几个方法成员
var methods=delegate1.GetType().GetMethods();
if (methods != null)
foreach (MethodInfo info in methods)
Console.WriteLine(info.Name);
Console.ReadKey();
}
}委托类包括以下几个重要方法
public class MyDelegate:MulticastDelegate
{
public MyDelegate(object target, int methodPtr);
//调用委托方法
public virtual void Invoke();
//异步委托
public virtual IAsyncResult BeginInvoke(AsyncCallback callback,object state);
public virtual void EndInvoke(IAsyncResult result);
}当调用Invoke（）方法时，对应此委托的所有方法都会被执行。而BeginInvoke与EndInvoke则支持委托方法的异步调用，由BeginInvoke启动的线程都属于CLR线程池中的工作者线程，在下面将详细说明。
4.5 利用BeginInvoke与EndInvoke完成异步委托方法
首先建立一个委托对象，通过IAsyncResult BeginInvoke(string name,AsyncCallback callback,object state) 异步调用委托方法，BeginInvoke 方法除最后的两个参数外，其它参数都是与方法参数相对应的。通过 BeginInvoke 方法将返回一个实现了 System.IAsyncResult 接口的对象，之后就可以利用EndInvoke（IAsyncResult ) 方法就可以结束异步操作，获取委托的运行结果。
class Program
{
delegate string MyDelegate(string name);
static void Main(string[] args)
{
ThreadMessage("Main Thread");
//建立委托
MyDelegate myDelegate = new MyDelegate(Hello);
//异步调用委托，获取计算结果
IAsyncResult result=myDelegate.BeginInvoke("Leslie", null, null);
//完成主线程其他工作
.............
//等待异步方法完成，调用EndInvoke(IAsyncResult)获取运行结果
string data=myDelegate.EndInvoke(result);
Console.WriteLine(data);
Console.ReadKey();
}
static string Hello(string name)
{
ThreadMessage("Async Thread");
Thread.Sleep(2000); //虚拟异步工作
return "Hello " + name;
}
//显示当前线程
static void ThreadMessage(string data)
{
string message = string.Format("{0}\n ThreadId is:{1}",
data,Thread.CurrentThread.ManagedThreadId);
Console.WriteLine(message);
}
}运行结果
4.6 善用IAsyncResult
在以上例子中可以看见，如果在使用myDelegate.BeginInvoke后立即调用myDelegate.EndInvoke，那在异步线程未完成工作以前主线程将处于阻塞状态，等到异步线程结束获取计算结果后，主线程才能继续工作，这明显无法展示出多线程的优势。此时可以好好利用IAsyncResult 提高主线程的工作性能，IAsyncResult有以下成员
public interface IAsyncResult
{
object AsyncState {get;} //获取用户定义的对象，它限定或包含关于异步操作的信息。
WailHandle AsyncWaitHandle {get;} //获取用于等待异步操作完成的 WaitHandle。
bool CompletedSynchronously {get;} //获取异步操作是否同步完成的指示。
bool IsCompleted {get;} //获取异步操作是否已完成的指示。
}通过轮询方式，使用IsCompleted属性判断异步操作是否完成，这样在异步操作未完成前就可以让主线程执行另外的工作。
class Program
{
delegate string MyDelegate(string name);
static void Main(string[] args)
{
ThreadMessage("Main Thread");
//建立委托
MyDelegate myDelegate = new MyDelegate(Hello);
//异步调用委托，获取计算结果
IAsyncResult result=myDelegate.BeginInvoke("Leslie", null, null);
//在异步线程未完成前执行其他工作
while (!result.IsCompleted)
{
Thread.Sleep(200); //虚拟操作
Console.WriteLine("Main thead do work!");
}
string data=myDelegate.EndInvoke(result);
Console.WriteLine(data);
Console.ReadKey();
}
static string Hello(string name)
{
ThreadMessage("Async Thread");
Thread.Sleep(2000);
return "Hello " + name;
}
static void ThreadMessage(string data)
{
string message = string.Format("{0}\n ThreadId is:{1}",
data,Thread.CurrentThread.ManagedThreadId);
Console.WriteLine(message);
}
}运行结果：
除此以外，也可以使用WailHandle完成同样的工作，WaitHandle里面包含有一个方法WaitOne（int timeout），它可以判断委托是否完成工作，在工作未完成前主线程可以继续其他工作。运行下面代码可得到与使用 IAsyncResult.IsCompleted 同样的结果，而且更简单方便 。
namespace Test
{
class Program
{
delegate string MyDelegate(string name);
static void Main(string[] args)
{
ThreadMessage("Main Thread");
//建立委托
MyDelegate myDelegate = new MyDelegate(Hello);
//异步调用委托，获取计算结果
IAsyncResult result=myDelegate.BeginInvoke("Leslie", null, null);
while (!result.AsyncWaitHandle.WaitOne(200))
{
Console.WriteLine("Main thead do work!");
}
string data=myDelegate.EndInvoke(result);
Console.WriteLine(data);
Console.ReadKey();
}
static string Hello(string name)
{
ThreadMessage("Async Thread");
Thread.Sleep(2000);
return "Hello " + name;
}
static void ThreadMessage(string data)
{
string message = string.Format("{0}\n ThreadId is:{1}",
data,Thread.CurrentThread.ManagedThreadId);
Console.WriteLine(message);
}
}当要监视多个运行对象的时候，使用IAsyncResult.WaitHandle.WaitOne可就派不上用场了。
幸好.NET为WaitHandle准备了另外两个静态方法：WaitAny（waitHandle[], int）与WaitAll (waitHandle[] , int)。
其中WaitAll在等待所有waitHandle完成后再返回一个bool值。
而WaitAny是等待其中一个waitHandle完成后就返回一个int，这个int是代表已完成waitHandle在waitHandle[]中的数组索引。
下面就是使用WaitAll的例子，运行结果与使用 IAsyncResult.IsCompleted 相同。
class Program
{
delegate string MyDelegate(string name);
static void Main(string[] args)
{
ThreadMessage("Main Thread");
//建立委托
MyDelegate myDelegate = new MyDelegate(Hello);
//异步调用委托，获取计算结果
IAsyncResult result=myDelegate.BeginInvoke("Leslie", null, null);
//此处可加入多个检测对象
WaitHandle[] waitHandleList = new WaitHandle[] { result.AsyncWaitHandle,........ };
while (!WaitHandle.WaitAll(waitHandleList,200))
{
Console.WriteLine("Main thead do work!");
}
string data=myDelegate.EndInvoke(result);
Console.WriteLine(data);
Console.ReadKey();
}
static string Hello(string name)
{
ThreadMessage("Async Thread");
Thread.Sleep(2000);
return "Hello " + name;
}
static void ThreadMessage(string data)
{
string message = string.Format("{0}\n ThreadId is:{1}",
data,Thread.CurrentThread.ManagedThreadId);
Console.WriteLine(message);
}
}4.7 回调函数
使用轮询方式来检测异步方法的状态非常麻烦，而且效率不高，有见及此，.NET为 IAsyncResult BeginInvoke（AsyncCallback , object）准备了一个回调函数。使用 AsyncCallback 就可以绑定一个方法作为回调函数，回调函数必须是带参数 IAsyncResult 且无返回值的方法： void AsycnCallbackMethod(IAsyncResult result) 。在BeginInvoke方法完成后，系统就会调用AsyncCallback所绑定的回调函数,最后回调函数中调用 XXX EndInvoke（IAsyncResult result) 就可以结束异步方法，它的返回值类型与委托的返回值一致。
class Program
{
delegate string MyDelegate(string name);
static void Main(string[] args)
{
ThreadMessage("Main Thread");
//建立委托
MyDelegate myDelegate = new MyDelegate(Hello);
//异步调用委托，获取计算结果
myDelegate.BeginInvoke("Leslie", new AsyncCallback(Completed), null);
//在启动异步线程后，主线程可以继续工作而不需要等待
for (int n = 0; n < 6; n++)
Console.WriteLine(" Main thread do work!");
Console.WriteLine("");
Console.ReadKey();
}
static string Hello(string name)
{
ThreadMessage("Async Thread");
Thread.Sleep(2000); \\模拟异步操作
return "\nHello " + name;
}
static void Completed(IAsyncResult result)
{
ThreadMessage("Async Completed");
//获取委托对象，调用EndInvoke方法获取运行结果
AsyncResult _result = (AsyncResult)result;
MyDelegate myDelegate = (MyDelegate)_result.AsyncDelegate;
string data = myDelegate.EndInvoke(_result);
Console.WriteLine(data);
}
static void ThreadMessage(string data)
{
string message = string.Format("{0}\n ThreadId is:{1}",
data, Thread.CurrentThread.ManagedThreadId);
Console.WriteLine(message);
}
}可以看到，主线在调用BeginInvoke方法可以继续执行其他命令，而无需再等待了，这无疑比使用轮询方式判断异步方法是否完成更有优势。
在异步方法执行完成后将会调用AsyncCallback所绑定的回调函数，注意一点，回调函数依然是在异步线程中执行，这样就不会影响主线程的运行，这也使用回调函数最值得青昧的地方。
在回调函数中有一个既定的参数IAsyncResult,把IAsyncResult强制转换为AsyncResult后，就可以通过 AsyncResult.AsyncDelegate 获取原委托，再使用EndInvoke方法获取计算结果。
运行结果如下：
如果想为回调函数传送一些外部信息，就可以利用BeginInvoke(AsyncCallback,object)的最后一个参数object,它允许外部向回调函数输入任何类型的参数。只需要在回调函数中利用 AsyncResult.AsyncState 就可以获取object对象。
class Program
{
public class Person
{
public string Name;
public int Age;
}
delegate string MyDelegate(string name);
static void Main(string[] args)
{
ThreadMessage("Main Thread");
//建立委托
MyDelegate myDelegate = new MyDelegate(Hello);
//建立Person对象
Person person = new Person();
person.Name = "Elva";
person.Age = 27;
//异步调用委托，输入参数对象person, 获取计算结果
myDelegate.BeginInvoke("Leslie", new AsyncCallback(Completed), person);
//在启动异步线程后，主线程可以继续工作而不需要等待
for (int n = 0; n < 6; n++)
Console.WriteLine(" Main thread do work!");
Console.WriteLine("");
Console.ReadKey();
}
static string Hello(string name)
{
ThreadMessage("Async Thread");
Thread.Sleep(2000);
return "\nHello " + name;
}
static void Completed(IAsyncResult result)
{
ThreadMessage("Async Completed");
//获取委托对象，调用EndInvoke方法获取运行结果
AsyncResult _result = (AsyncResult)result;
MyDelegate myDelegate = (MyDelegate)_result.AsyncDelegate;
string data = myDelegate.EndInvoke(_result);
//获取Person对象
Person person = (Person)result.AsyncState;
string message = person.Name + "'s age is " + person.Age.ToString();
Console.WriteLine(data+"\n"+message);
}
static void ThreadMessage(string data)
{
string message = string.Format("{0}\n ThreadId is:{1}",
data, Thread.CurrentThread.ManagedThreadId);
Console.WriteLine(message);
}
}运行结果:
关于I/O线程、SqlCommand多线程查询、PLINQ、定时器与锁的内容将在C#综合揭秘——细说多线程（下）中详细介绍。