使用异步 I/O 完成事件，线程池中的线程将只在收到数据时对数据进行处理，一旦处理完数据，该线程就会返回到线程池中。
若要进行异步 I/O 调用，必须将操作系统 I/O 句柄与线程池相关联，并且必须指定一个回调方法。当 I/O 操作完成后，线程池中的线程将调用该回调方法。
下面的 C# 代码示例说明了一个简单的异步 I/O 操作。
** 注意 ** 该示例需要 100MB 以上的可用内存。
[C#]
using System;
using System.IO;
using System.Threading;
using System.Runtime.InteropServices;
public class BulkImageProcAsync{
public const String ImageBaseName = "tmpImage-";
public const int numImages = 200;
public const int numPixels = 512*512;
// ProcessImage has a simple O(N) loop, and you can vary the number
// of times you repeat that loop to make the application more CPU-bound
// or more I/O-bound.
public static int processImageRepeats = 20;
// Threads must decrement NumImagesToFinish, and protect
// their access to it through a mutex.
public static int NumImagesToFinish = numImages;
public static Object NumImagesMutex = new Object[0];
// WaitObject is signalled when all image processing is done.
public static Object WaitObject = new Object[0];
public class ImageStateObject{
public byte[] pixels;
public int imageNum;
public FileStream fs;
}
public static void MakeImageFiles(){
int sides = (int) Math.Sqrt(numPixels);
Console.Write("Making "+numImages+" "+sides+"x"+sides+" images... ");
byte[] pixels = new byte[numPixels];
for(int i=0; i<numPixels; i++)
pixels[i] = (byte) i;
for(int i=0; i<numImages; i++){
FileStream fs = new FileStream(
ImageBaseName+i+".tmp",
FileMode.Create,
FileAccess.Write,
FileShare.None,
8192,
false
);
fs.Write(pixels, 0, pixels.Length);
FlushFileBuffers(fs.Handle);
fs.Close();
}
Console.WriteLine("Done.");
}
public static void ReadInImageCallback(IAsyncResult asyncResult){
ImageStateObject state = (ImageStateObject) asyncResult.AsyncState;
Stream stream = state.fs;
int bytesRead = stream.EndRead(asyncResult);
if (bytesRead != numPixels)
throw new Exception("In ReadInImageCallback, got wrong number of bytes from the image! got: " + bytesRead);
ProcessImage(state.pixels, state.imageNum);
stream.Close();
// Now write out the image. No async here.
FileStream fs = new FileStream(
ImageBaseName + state.imageNum + ".done",
FileMode.Create,
FileAccess.Write,
FileShare.None,
4096,
false
);
fs.Write(state.pixels, 0, numPixels);
fs.Close();
// This application model uses too much memory.
// Releasing memory as soon as possible is a good idea, especially global
// state.
state.pixels = null;
// Record that an image is done now.
lock(NumImagesMutex){
NumImagesToFinish--;
if (NumImagesToFinish==0){
lock(WaitObject){
Monitor.Pulse(WaitObject);
}
}
}
}
public static void ProcessImage(byte[] pixels, int imageNum){
Console.WriteLine("ProcessImage "+imageNum);
// Do some CPU-intensive operation on the image.
for(int i=0; i<processImageRepeats; i++)
for(int j=0; j<numPixels; j++)
pixels[j] += 1;
Console.WriteLine("ProcessImage "+imageNum+" done.");
}
public static void ProcessImagesInBulk(){
Console.WriteLine("Processing images... ");
long t0 = Environment.TickCount;
NumImagesToFinish = numImages;
AsyncCallback readImageCallback = new AsyncCallback(ReadInImageCallback);
for(int i=0; i<numImages; i++){
ImageStateObject state = new ImageStateObject();
state.pixels = new byte[numPixels];
state.imageNum = i;
// Very large items are read only once, so the
// buffer on the file stream can be very small to save memory.
FileStream fs = new FileStream(
ImageBaseName+i+".tmp",
FileMode.Open,
FileAccess.Read,
FileShare.Read,
1,
true
);
state.fs = fs;
fs.BeginRead(state.pixels, 0, numPixels, readImageCallback, state);
}
// Determine whether all images are done being processed.
<P class=MsoNormal style="MARGIN: 0cm 0cm 0pt; TEXT-ALIGN: left; mso-pagination: widow-orphan; tab-stops: 45.8pt 91.6pt 137.4pt 183.2pt 229.0pt 274.8pt 320.