异步设备IO OVERLAPPED结构(设备内核对象 事件内核对象 可提醒IO)

　　同步IO是指：线程在发起IO请求后会被挂起，IO完成后继续执行。

　　异步IO是指：线程发起IO请求后并不会挂起而是继续执行。IO完毕后会得到设备驱动程序的通知。

　　一.异步准备与OVERLAPPED结构

　　（1）.为了以异步的方式来访问设备，必须先调用CreateFile，并在dwFlagsAndAttributes参数中指定FILE_FLAG_OVERLAPPED标志来打开设备。该标志告诉系统要以异步的方式来访问设备。

　　为了将I/O请求加入设备驱动程序的队列中，必须使用ReadFile和WriteFile函数：

　　

HANDLE CreateFile(
  LPCTSTR lpFileName,                                         // 文件名/设备路径 设备的名称
  DWORD dwDesiredAccess,                                  // 访问方式
  DWORD dwShareMode,                                      // 共享方式
  LPSECURITY_ATTRIBUTES lpSecurityAttributes,  // 安全描述符指针
  DWORD dwCreationDisposition,                          // 创建方式
  DWORD dwFlagsAndAttributes,                          // 文件属性及标志
  HANDLE hTemplateFile                                      // 模板文件的句柄
);

　　当调用ReadFile，WriteFile这两个函数中任何一个时，函数会检查hFile参数标识的设备是否用FILE_FLAG_OVERLAPPED标志打开的。如果打开设备时指定了这个标志，那么函数会执行异步设备I/O。

BOOL WINAPI ReadFile(
_In_ HANDLE hFile,
_Out_ LPVOID lpBuffer,
_In_ DWORD nNumberOfBytesToRead,
_Out_opt_ LPDWORD lpNumberOfBytesRead,
_Inout_opt_ LPOVERLAPPED lpOverlapped
);

BOOL WINAPI ReadFile(
  _In_         HANDLE hFile,
  _Out_        LPVOID lpBuffer,
  _In_         DWORD nNumberOfBytesToRead,
  _Out_opt_    LPDWORD lpNumberOfBytesRead,
  _Inout_opt_  LPOVERLAPPED lpOverlapped
);

　　

　　（2）.再来看OVERLAPPED结构：

　　

typedef struct _OVERLAPPED {
    ULONG_PTR Internal;
    ULONG_PTR InternalHigh;
    union {
        struct {
            DWORD Offset;
            DWORD OffsetHigh;
        } DUMMYSTRUCTNAME;
        PVOID Pointer;
    } DUMMYUNIONNAME;

    HANDLE  hEvent;
} OVERLAPPED, *LPOVERLAPPED;

　　1.Internal成员：这个成员用来保存已处理的I/O请求的错误码.

　　   InternalHigh成员：当异步I/O请求完成的时候，这个成员用来保存已传输的字节数。

　　2..Offset和OffsetHigh成员，构成一个64位的偏移量，它们表示当访问文件的时候应该从哪里开始进行I/O操作。每个文件内核对象都有一个与之相关联的文件指针。在执行异步I/O的时候，系统会忽略文件指针。这是为了避免在对同一个对象进行多个异步调用的时候出现混淆，所有异步I/O请求必须在OVERLAPPED结构中指定起始偏移量。非文件设备会忽略这两个参数，必须将其初始化为0，否则I/O请求会失败。

　　(3.)异步设备IO注意事项

　　　　1:异步IO不会按照你的投递顺序来执行,驱动会选择他认为最快的方式来组合这些投递

　　　　2:错误处理,以文件IO为例,当我们投递一个异步ReadFile()时,设备驱动程序可能会以同步方式执行,例如如果设备驱动程序发现要读取的数据在文件缓冲里时,就不会投递这个异步设备IO,而是直接将数据复制进我们的缓冲区

　　　　3.如果IO是同步方式执行,ReadFile()和WriteFile()返回非零值,如果是异步或者出现错误,返回FALSE,调用GetLastError()获得错误码,如果返回的是ERROR_IO_PENDING,那么IO请求已经被成功地加入了队列。

　　二.接收IO请求完成的方法　　

Windows提供了4种不同的技术方法来得到I/O完成的通知。

技术	概要
通知一个设备内核对象	当一个设备同时有多个IO请求的时候，该方法不适用。允许一个线程发送一个IO请求，另一个线程处理之。
通知一个事件内核对象	允许一个设备同时有多个IO请求。允许一个线程发送一个IO请求，另一线程处理之。
警告IO	允许一个设备同时有多个IO请求。必须在同一个线程中发送并处理同一个IO请求。
IO完成端口	允许一个设备同时有多个IO请求。允许一个线程发送一个IO请求，另一个线程处理之。该方法伸缩性好，而且性能高。

　　

　　1.触发设备内核对象

　　（1）Read/WriteFile在将I/O请求添加到队列之前，会先将对象设为未触发状态。当设备驱动程序完成了请求之后，会将设备内核对象设为触发状态，线程可以通过WaitForSingalObject或WaitForMultiObject来检查一个异步IO请求是否完成。

　　（2）不能向同一个设备发出多个IO请求。

　　2.触发事件内核对象

　　（1）在每个I/O请求的OVERLAPPED结构体的hEvent创建一个用来监听该请求完成的事件对象。当一个异步I/O请求完成时，设备驱动程序会调用SetEvent来触发事件。驱动程序仍然会像从前一样，将设备对象也设为触发状态，因为己经有了可用的事件对象，所以可以通过SetFileCompletionNoticationModes(hFile,FILE_SKIP_SET_EVENT_ON_HANDLE)来告诉操作系统在操作完成时，不要触发文件对象。

　　3.使用可提醒IO　

　　（1）创建线程时，会同时创建一个与线程相关联的APC队列（异步过程调用），可以告诉设备程序驱动程序在I/O完成时，为了将通知信息添加到线程的APC队列中，需要调用ReadFileEx和WriteFileEx函数。

　　（2）ReadFile/WriteFileEx函数与Read/WriteFile最大的不同在于最后一个参数，这是一个回调函数（也叫完成函数）的地址，当*Ex发出一个I/O请求时，这两个函数会将回调函数的地址传给设备驱动程序。当设备驱动程序完成I/O请求的时候，会在发出I/O请求的线程的APC队列中添加一项。该项包含了完成函数的地址以及发出I/O请求时使用的OVERLAPPED的地址。

　　对于这种异步设备I/O方式，确实没什么用。重要的是微软为可提醒IO构建的基础设施——APC（Asynchronous Procedure Call），异步过程调用。

　　当创建一个线程的时候，系统会为线程维护一个APC队列，该队列中的项目想要得到执行，线程必须处于可提醒等待状态，即使用SleepEx、WaitForSingleObjectEx、WaitForMultipleObjectsEx等函数，并且把最后一个参数设置为TRUE。当线程处于可提醒等待状态时，线程就会执行APC队列中的APC，之后执行过的APC就会清除队列，再进行下一次执行APC（如果APC队列中还有未执行的APC）。

　　在这一小节中，作者的用意就是不要使用可提醒I/O方式进行异步设备I/O——因为可提醒I/O的两大缺陷：回调函数的累赘和线程的无负载均衡机制。

// Overlapped.cpp : 定义控制台应用程序的入口点。

#include "stdafx.h"
#include <windows.h>
#include <iostream>
/*
Internal成员：这个成员用来保存已处理的I/O请求的错误码.
InternalHigh成员：当异步I/O请求完成的时候，这个成员用来保存已传输的字节数。
在当初设计OVERLAPPED结构的时候，Microsoft决定不公开Internal和InternalHigh成员（名副其实）。随着时间的推移，Microsoft认识到这些成员包含的信息会对开发人员有用，因此把它们公开了。但是，Microsoft没有改变这些成员的名字，这是因为操作系统的源代码频繁地用到它们，而Microsoft并不想为此修改源代码。
*/
using namespace std;

#define PAGE_SIZE 0x1000
void Sub_1();   //ReadFile 异步操作
void Sub_2();   //ReadFileEx
DWORD WINAPI Sub_1ThreadProcedure(LPVOID ParameterData);
DWORD WINAPI Sub_2ThreadProcedure(LPVOID ParameterData);
OVERLAPPED __Overlapped = { 0 };
char __BufferData[4] = {0};

int main()
{

	//Sub_1();   //触发事件内核对象
	Sub_2();     //可提醒IO
}
void Sub_1()
{
	BOOL       IsOk = FALSE;
	DWORD      ReturnLength = 0;
	HANDLE FileHandle = CreateFile(L"ReadMe.txt", GENERIC_ALL, FILE_SHARE_READ | FILE_SHARE_WRITE,
		NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL);
	if (FileHandle == INVALID_HANDLE_VALUE)
	{
		int LastError = GetLastError();
		goto Exit;
	}
	//当一个异步IO请求完成的时候，驱动程序检查OVERLAPPED结构的hEvent成员是否为NULL
	//如果hEvent不为NULL，那么驱动程序会调用SetEvent来触发事件，这时候就是使用事件对象来检查一个设备操作是否完成，而不是等待设备(文件)对象
	__Overlapped.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);  //绝对要创建
	HANDLE ThreadHandle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)Sub_1ThreadProcedure,
		(LPVOID)FileHandle, 0, NULL);

	if (__BufferData == NULL)
	{
		goto Exit;
	}
	IsOk = ReadFile(FileHandle, __BufferData, 4, &ReturnLength, &__Overlapped);  //事件必须创建
	if (IsOk == FALSE)
	{
		int LastError = GetLastError();

		if (LastError == ERROR_IO_PENDING)
		{
			//成功
			printf("ERROR_IO_PENDING\r\n");  //重叠I/O返回标志
		}
	}
	WaitForSingleObject(ThreadHandle, INFINITE);
Exit:
	if (FileHandle != NULL)
	{
		CloseHandle(FileHandle);
		FileHandle = NULL;
	}
	printf("\r\n");
	return;
}
DWORD WINAPI Sub_1ThreadProcedure(LPVOID ParameterData)
{
	HANDLE FileHandle = (HANDLE)ParameterData;
	BOOL  IsOk = FALSE;
	DWORD ReturnLength = 0;
	while (1)
	{
		IsOk = WaitForSingleObject(__Overlapped.hEvent, INFINITE);
		IsOk -= WAIT_OBJECT_0;
		if (IsOk == 0)
		{
			IsOk = GetOverlappedResult(FileHandle, &__Overlapped, &ReturnLength, INFINITE);

			if (IsOk==TRUE)
			{
				int i = 0;
				for (i = 0; i < ReturnLength; i++)
				{
					printf("%c", __BufferData[i]);
				}
				__Overlapped.Offset += ReturnLength;
				ReadFile(FileHandle, &__BufferData, 4, &ReturnLength, &__Overlapped);
			}

			else
			{
				//数据完毕
				break;
			}

		}
		else
		{
			return 0;
		}
	}

	return 0;
}

void Sub_2()
{
	BOOL       IsOk = FALSE;
	HANDLE FileHandle = CreateFile(L"ReadMe.txt", GENERIC_ALL, FILE_SHARE_READ | FILE_SHARE_WRITE,
		NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL);
	if (FileHandle == INVALID_HANDLE_VALUE)
	{
		int LastError = GetLastError();
		goto Exit;
	}

	//__Overlapped.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);   //不能提供该事件
	HANDLE ThreadHandle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)Sub_2ThreadProcedure,
		(LPVOID)FileHandle, 0, NULL);

	if (__BufferData == NULL)
	{
		goto Exit;
	}
	IsOk = ReadFileEx(FileHandle, __BufferData, 4, &__Overlapped, NULL);
	if (IsOk == FALSE)
	{
		int LastError = GetLastError();

		if (LastError == ERROR_IO_PENDING)
		{
			//成功
			printf("ERROR_IO_PENDING\r\n");  //重叠I/O返回标志
		}
	}
	WaitForSingleObject(ThreadHandle, INFINITE);
Exit:
	if (FileHandle != NULL)
	{
		CloseHandle(FileHandle);
		FileHandle = NULL;
	}
	printf("\r\n");
	return;
}

DWORD WINAPI Sub_2ThreadProcedure(LPVOID ParameterData)
{
	HANDLE FileHandle = (HANDLE)ParameterData;
	DWORD ReturnLength = 0;
	BOOL  IsOk = FALSE;
	while (1)
	{
		IsOk = GetOverlappedResult(FileHandle, &__Overlapped, &ReturnLength, TRUE);
		//当一个可提醒IO完成时，设备驱动程序不会试图去触发一个事件对象
		//IsOk = WaitForSingleObject(__Overlapped.hEvent, INFINITE);
		if (IsOk == TRUE)
		{
			int i = 0;
			for (i = 0; i < ReturnLength; i++)
			{
				printf("%c", __BufferData[i]);
			}

			__Overlapped.Offset += ReturnLength;
			ReadFileEx(FileHandle, &__BufferData, 4, &__Overlapped, NULL);
		}
		else
		{
			return 0;
		}
	}

	return 0;
}

　　

　　　　

// Overlapped.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <windows.h>
#include <iostream>
using namespace std;
VOID CALLBACK CompletionRoutine(
	_In_    DWORD        ErrorCode,
	_In_    DWORD        ReturnLength,
	_Inout_ LPOVERLAPPED Overlapped);
HANDLE __FileHandle = NULL;
char __BufferData[20] = {0};
int main()
{
	BOOL       IsOk = FALSE;
	OVERLAPPED Overlapped = { 0 };
	__FileHandle = CreateFile(L"ReadMe.txt", GENERIC_ALL, FILE_SHARE_READ | FILE_SHARE_WRITE,
		NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL|FILE_FLAG_OVERLAPPED, NULL);
	if (__FileHandle == INVALID_HANDLE_VALUE)
	{
		int LastError = GetLastError();
		goto Exit;
	}
	IsOk = ReadFileEx(__FileHandle, __BufferData, 4,&Overlapped,
		(LPOVERLAPPED_COMPLETION_ROUTINE)CompletionRoutine);
	if (IsOk == FALSE)
	{
		int LastError = GetLastError();
		if (LastError == ERROR_IO_PENDING)
		{
			//成功
		}
	}
Exit:
	SleepEx(0,TRUE);
	if (__FileHandle != NULL)
	{
		CloseHandle(__FileHandle);
		__FileHandle = NULL;
	}
	printf("Input AnyKey To Exit\r\n");
	getchar();
	return 0;
}
VOID CALLBACK CompletionRoutine(
	_In_    DWORD        ErrorCode,
	_In_    DWORD        ReturnLength,
	_Inout_ LPOVERLAPPED Overlapped
)
{
	if (ErrorCode == ERROR_SUCCESS)
	{
		int i = 0;
		for (i = 0; i < ReturnLength; i++)
		{
			printf("%c", __BufferData[i]);
		}

		Overlapped->Offset += ReturnLength;
		ReadFileEx(__FileHandle, __BufferData, 4, Overlapped,
			(LPOVERLAPPED_COMPLETION_ROUTINE)CompletionRoutine);
	}
	else if (ErrorCode==ERROR_HANDLE_EOF)
	{
		//数据完成
		printf("\r\n");
	}
	else
	{

	}
}