IO异步机制

#include <iostream>
#include <windows.h>
#include <bitset>
#include <vector>
#include <assert.h>
using namespace std;

vector<string> pTempInfo;

VOID WINAPI APC_A ( DWORD dwError, DWORD cbTransferred, LPOVERLAPPED lpo )
{
pTempInfo.push_back ( "执行IO_A的完成例程" ) ;
}
VOID WINAPI APC_B ( DWORD dwError, DWORD cbTransferred, LPOVERLAPPED lpo )
{
pTempInfo.push_back ( "执行IO_B的完成例程" ) ;
}
VOID WINAPI APC_C ( DWORD dwError, DWORD cbTransferred, LPOVERLAPPED lpo )
{
pTempInfo.push_back ( "执行IO_C的完成例程" ) ;
}

void OnTest()
{
// APC测试
HANDLE    hFile_A, hFile_B, hFile_C ;
OVERLAPPED  ov_A = {0}, ov_B = {0}, ov_C = {0} ;

#define C_SIZE 1024 * 1024 * 32

string  szText_A = "Sample A !" ;
string  szText_B = "Sampel B !" ;
string  szText_C ;
szText_C.resize ( C_SIZE ) ;
memset ( &(szText_C[0]), 0x40, C_SIZE ) ;

pTempInfo.clear () ;

hFile_A = CreateFileA ( "A.txt", GENERIC_WRITE, 0, NULL, \
CREATE_ALWAYS , FILE_FLAG_OVERLAPPED | FILE_FLAG_DELETE_ON_CLOSE, NULL ) ;
hFile_B = CreateFileA ( "B.txt", GENERIC_WRITE, 0, NULL, \
CREATE_ALWAYS, FILE_FLAG_OVERLAPPED | FILE_FLAG_DELETE_ON_CLOSE, NULL ) ;
hFile_C = CreateFileA ( "C.txt", GENERIC_WRITE, 0, NULL, \
CREATE_ALWAYS, FILE_FLAG_OVERLAPPED | FILE_FLAG_DELETE_ON_CLOSE, NULL ) ;

WriteFileEx ( hFile_A, &(szText_A[0]), szText_A.length(), &ov_A, APC_A ) ;
pTempInfo.push_back ( "启动IO_A, 并立即返回" ) ;

WriteFileEx ( hFile_B, &(szText_B[0]), szText_B.length(), &ov_B, APC_B ) ;
pTempInfo.push_back ( "启动IO_B, 并立即返回" ) ;

WriteFileEx ( hFile_C, &(szText_C[0]), szText_C.size(), &ov_C, APC_C ) ;
pTempInfo.push_back ( "启动IO_C, 并立即返回" ) ;

pTempInfo.push_back ( "进入可变等待状态" ) ;
SleepEx ( 1, true ) ;
pTempInfo.push_back ( "结束可变等待状态" ) ;

pTempInfo.push_back ( "进入可变等待状态" ) ;
SleepEx ( 10000, true ) ;
pTempInfo.push_back ( "结束可变等待状态" ) ;

CloseHandle ( hFile_A ) ;
CloseHandle ( hFile_B ) ;
CloseHandle ( hFile_C ) ;

vector<string>::iterator p ;
for ( p = pTempInfo.begin(); p != pTempInfo.end(); p++ )
{
cout << p->c_str() << "\n";
}
}

int main()
{
OnTest();
return 0;
}

#if 0

int main ()
{
int a = 0;
HANDLE hHnd = NULL;
vector<string> vecOut;
char *szTmp1 = new char[409600];
char *szTmp2 = new char[409600];
char *szTmp3 = new char[409600];

DWORD	dwRet1 = 0;
DWORD	dwRet2 = 0;
DWORD	dwRet3 = 0;

HANDLE hFile1 = CreateFileA("F:\\2.log", FILE_GENERIC_READ|FILE_SHARE_WRITE, FILE_SHARE_READ, NULL, OPEN_ALWAYS, FILE_FLAG_OVERLAPPED, NULL);
assert(INVALID_HANDLE_VALUE != hFile1);

HANDLE hEvent1 = CreateEvent(NULL, FALSE, FALSE, NULL);
HANDLE hEvent2 = CreateEvent(NULL, FALSE, FALSE, NULL);
HANDLE hEvent3 = CreateEvent(NULL, FALSE, FALSE, NULL);

OVERLAPPED	ov1 = {0,};
OVERLAPPED	ov2 = {0};
OVERLAPPED	ov3 = {0};

ov1.hEvent = hEvent1;
ov2.hEvent = hEvent2;
ov2.hEvent = hEvent3;

ov1.Offset = 8192;
ov2.Offset = 4096;
ov3.Offset = 2042;

memset(szTmp1, 1, 409600);
memset(szTmp2, 2, 409600);
memset(szTmp3, 3, 409600);

WriteFile(hFile1, szTmp1, 2048, &dwRet1, &ov1);
WriteFile(hFile1, szTmp2, 1024, &dwRet2, &ov2);
WriteFile(hFile1, szTmp3, 512, &dwRet3, &ov3);

bool bOk = false;
while(!bOk)
{
bOk = true;

if(!GetOverlappedResult(hFile1, &ov1, &dwRet1, FALSE))
{
bOk = false;
}
else
{
vecOut.push_back("1 over");
}

if(!GetOverlappedResult(hFile1, &ov2, &dwRet2, FALSE))
{
bOk = false;
}
else
{
vecOut.push_back("2 over");
}

if(!GetOverlappedResult(hFile1, &ov3, &dwRet3, FALSE))
{
bOk = false;
}
else
{
vecOut.push_back("3 over");
}
}

for (size_t i=0; i<vecOut.size(); i++)
{
cout << vecOut[i] << "\n";
}

return 0;

}
#endif