异步过程调用(Asynchronous Procedure Call)

/*Demonstrates how to use APC's（asynchronous procedure
calls）instread of signaled objects to service multiple
outstanding overlapped operations on a file*/
#define WIN32_LEAN_AND_MEAN
#include<stdio.h>
#include<stdlib.h>
#include<Windows.h>
#include "MtVerify.h"
//constants
#define MAX_REQUESTS 5
#define READ_SIZE 512
#define MAX_TRY_COUNT 5


//Function prototypes
void CheckOsVersion();
int QueueRequest(int nIndex, DWORD dwLocation, DWORD dwAmount);


//Global variables
//Need a single event object so we know when all I/O is finished 
HANDLE ghEvent;
//Keep track of each individual I/O operation
OVERLAPPED gOverlapped[MAX_REQUESTS];
//Handle to the file of interest
HANDLE ghFile;
//Need a place to put all this data
char gBuffers[MAX_REQUESTS][READ_SIZE];
int nCompletionCount;
/*  I/O Completion routine gets called 
when app is alertable(in WaitForSingleObjectEx)
and an overlapped I/O operation has completed.
*/
VOID WINAPI FileIOCompletionRoutine(DWORD dwErrorCode,
DWORD dwNumberOfBytesTransfered,
LPOVERLAPPED lpvOverlapped)
{
//The event handle is really the user defined data
int nIndex = (int)(lpvOverlapped->hEvent);
printf("Read #%d returned %d.%d bytes were read.\n", nIndex, dwErrorCode, dwNumberOfBytesTransfered);
if (++nCompletionCount == MAX_REQUESTS)
{
SetEvent(ghEvent);//cause the wait to terminate
}
}
int main()
{
int i;
char szPath[MAX_PATH];
CheckOsVersion();
//NEED to know when to stop
MTVERIFY(ghEvent = CreateEvent(NULL, TRUE,
FALSE, NULL));
GetWindowsDirectory(LPWSTR(szPath), sizeof(szPath));
strcat(szPath, "\\WINHLP32.EXE");
//open the file for overlapped reads 
ghFile = CreateFile(LPCWSTR(szPath), GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED,NULL);
if (ghFile == INVALID_HANDLE_VALUE)
{
printf("Could not open %s \n", szPath);
return -1;
}
//Queue up a few requests
for (i = 0; i < MAX_REQUESTS; i++)
{
//Read some bytes every few K
QueueRequest(i, i * 16384, READ_SIZE);
}
printf("QUEUED!!\n"); 
//wait for all the operations to complete.
for (;;)
{
DWORD rc;
rc = WaitForSingleObjectEx(ghEvent, INFINITE, TRUE);
if (rc == WAIT_OBJECT_0)
break;
MTVERIFY(rc == WAIT_IO_COMPLETION);
}
CloseHandle(ghFile);
return EXIT_SUCCESS;
}
/*call readfileEx to start an overlapped request
make sure we handle errors that are recoverable
*/
int QueueRequest(int nIndex, DWORD dwLocation, DWORD dwAmount)
{
int i;
BOOL rc;
DWORD err;
gOverlapped[nIndex].hEvent = (HANDLE)nIndex;
gOverlapped[nIndex].Offset = dwLocation;
for (i = 0; i < MAX_TRY_COUNT; i++)
{
rc = ReadFileEx(ghFile,
gBuffers[nIndex],
dwAmount, &gOverlapped[nIndex],
FileIOCompletionRoutine);
//Handle success
if (rc)
{
//asynchronous i/o is still in progress
printf("Read #%d queued for overlapped I/O.\n");
return TRUE;
}
err = GetLastError();
//Handle recoverable error
if (err == ERROR_INVALID_USER_BUFFER
|| err == ERROR_NOT_ENOUGH_QUOTA
|| err == ERROR_NOT_ENOUGH_MEMORY)
{
Sleep(50);//wait around and try later
continue;
}
//Give up on fatal error.
break;
}
printf("ReadFileEx failed.\n");
return -1;
}
//make sure we are running under an operating 
//system that supports overlapped I/O to files/
void CheckOsVersion()
{
OSVERSIONINFO ver;
BOOL bResult;
ver.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
bResult = GetVersionEx((LPOSVERSIONINFO)&ver);
if ((!bResult) || (ver.dwPlatformId != VER_PLATFORM_WIN32_NT))
{
fprintf(stderr, "OpByAPC must be run under Windows NT.\n");
exit(EXIT_FAILURE);
}


}