Socket I/O模型之重叠I/O(overlapped I/O)--完成例程方式

C++代码

// write by larry

// 2009-8-20

// This is a server using overlapped IO(completion routine).

#include "stdafx.h"

#include <WINSOCK2.H>

#include <stdio.h>

#pragma comment(lib, "ws2_32.lib")

#define PORT 5150

#define MSGSIZE 1024

typedef struct

{

WSAOVERLAPPED overlap;

WSABUF Buffer;

char szMessage[MSGSIZE];

DWORD NumberOfBytesRecvd;

DWORD Flags;

SOCKET sClient;

} PER_IO_OPERATION_DATA, *LPPER_IO_OPERATION_DATA;

int g_iTotalConn = 0;

SOCKET g_CliSocketArr[MAXIMUM_WAIT_OBJECTS];

WSAEVENT g_CliEventArr[MAXIMUM_WAIT_OBJECTS];

LPPER_IO_OPERATION_DATA g_pPerIoDataArr[MAXIMUM_WAIT_OBJECTS];

DWORD WINAPI WorkerThread(LPVOID lpParam);

void CALLBACK CompletionRoutine(DWORD dwError, DWORD cbTransferred, LPWSAOVERLAPPED lpOverlapped, DWORD dwFlags);

SOCKET g_sNewClientConnection;

BOOL g_bNewConnectionArrived = FALSE;

int main(int argc, char* argv[])

{

WSADATA wsaData;

SOCKET sListen;

SOCKADDR_IN local, client;

DWORD dwThreadId;

int iAddrSize = sizeof(SOCKADDR_IN);

// Initialize windows socket library

WSAStartup(0x0202, &wsaData);

// Create listening socket

sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

// Bind

local.sin_family = AF_INET;

local.sin_addr.S_un.S_addr = htonl(INADDR_ANY);

local.sin_port = htons(PORT);

bind(sListen, (sockaddr*)&local, sizeof(SOCKADDR_IN));

// Listen

listen(sListen, 3);

// Create worker thread

CreateThread(NULL, 0, WorkerThread, NULL, 0, &dwThreadId);

while (TRUE)

{

// Accept a connection

g_sNewClientConnection = accept(sListen, (sockaddr*)&client, &iAddrSize);

g_bNewConnectionArrived = TRUE;

printf("Accepted client:%s:%d\n", inet_ntoa(client.sin_addr), ntohs(client.sin_port));

}

return 0;

}

DWORD WINAPI WorkerThread(LPVOID lpParam)

{

LPPER_IO_OPERATION_DATA lpPerIOData = NULL;

while (TRUE)

{

if (g_bNewConnectionArrived)

{

// Launch an asynchronous operation for new arrived connection

lpPerIOData = (LPPER_IO_OPERATION_DATA)HeapAlloc(

GetProcessHeap(),

HEAP_ZERO_MEMORY,

sizeof(PER_IO_OPERATION_DATA));

lpPerIOData->Buffer.len = MSGSIZE;

lpPerIOData->Buffer.buf = lpPerIOData->szMessage;

lpPerIOData->sClient = g_sNewClientConnection;

WSARecv(lpPerIOData->sClient,

&lpPerIOData->Buffer,

1,

&lpPerIOData->NumberOfBytesRecvd,

&lpPerIOData->Flags,

&lpPerIOData->overlap,

CompletionRoutine);

g_bNewConnectionArrived = FALSE;

}

SleepEx(1000, TRUE);

}

return 0;

}

void CALLBACK CompletionRoutine(DWORD dwError, DWORD cbTransferred, LPWSAOVERLAPPED lpOverlapped, DWORD dwFlags)

{

LPPER_IO_OPERATION_DATA lpPerIOData = (LPPER_IO_OPERATION_DATA)lpOverlapped;

if (dwError != 0 || cbTransferred == 0)

{

// Connection was closed by client

closesocket(lpPerIOData->sClient);

HeapFree(GetProcessHeap(), 0, lpPerIOData);

}

else

{

lpPerIOData->szMessage[cbTransferred] = '\0';

send(lpPerIOData->sClient, lpPerIOData->szMessage, cbTransferred, 0);

// Launch another asynchronous operation

memset(&lpPerIOData->overlap, 0, sizeof(WSAOVERLAPPED));

lpPerIOData->Buffer.len = MSGSIZE;

lpPerIOData->Buffer.buf = lpPerIOData->szMessage;

WSARecv(lpPerIOData->sClient,

&lpPerIOData->Buffer,

1,

&lpPerIOData->NumberOfBytesRecvd,

&lpPerIOData->Flags,

&lpPerIOData->overlap,

CompletionRoutine);

}

}

// writeby larry

//2009-8-20

// Thisis a server using overlapped IO(completion routine).

#include"stdafx.h"

#include<WINSOCK2.H>

#include<stdio.h>

#pragmacomment(lib, "ws2_32.lib")

#definePORT 5150

#defineMSGSIZE 1024

typedefstruct

{

WSAOVERLAPPED overlap;

WSABUF Buffer;

char szMessage[MSGSIZE];

DWORD NumberOfBytesRecvd;

DWORD Flags;

SOCKET sClient;

}PER_IO_OPERATION_DATA, *LPPER_IO_OPERATION_DATA;

int g_iTotalConn = 0;

SOCKET g_CliSocketArr[MAXIMUM_WAIT_OBJECTS];

WSAEVENT g_CliEventArr[MAXIMUM_WAIT_OBJECTS];

LPPER_IO_OPERATION_DATAg_pPerIoDataArr[MAXIMUM_WAIT_OBJECTS];

DWORDWINAPI WorkerThread(LPVOID lpParam);

voidCALLBACK CompletionRoutine(DWORD dwError, DWORD cbTransferred, LPWSAOVERLAPPEDlpOverlapped, DWORD dwFlags);

SOCKETg_sNewClientConnection;

BOOLg_bNewConnectionArrived = FALSE;

intmain(int argc, char* argv[])

{

WSADATA wsaData;

SOCKET sListen;

SOCKADDR_IN local, client;

DWORD dwThreadId;

int iAddrSize = sizeof(SOCKADDR_IN);

// Initialize windows socket library

WSAStartup(0x0202, &wsaData);

// Create listening socket

sListen = socket(AF_INET, SOCK_STREAM,IPPROTO_TCP);

// Bind

local.sin_family = AF_INET;

local.sin_addr.S_un.S_addr =htonl(INADDR_ANY);

local.sin_port = htons(PORT);

bind(sListen, (sockaddr*)&local,sizeof(SOCKADDR_IN));

// Listen

listen(sListen, 3);

// Create worker thread

CreateThread(NULL, 0, WorkerThread, NULL, 0,&dwThreadId);

while (TRUE)

{

// Accept a connection

g_sNewClientConnection = accept(sListen,(sockaddr*)&client, &iAddrSize);

g_bNewConnectionArrived = TRUE;

printf("Acceptedclient:%s:%d\n", inet_ntoa(client.sin_addr), ntohs(client.sin_port));

}

return 0;

}

DWORDWINAPI WorkerThread(LPVOID lpParam)

{

LPPER_IO_OPERATION_DATA lpPerIOData = NULL;

while (TRUE)

{

if (g_bNewConnectionArrived)

{

// Launch an asynchronous operation fornew arrived connection

lpPerIOData =(LPPER_IO_OPERATION_DATA)HeapAlloc(

GetProcessHeap(),

HEAP_ZERO_MEMORY,

sizeof(PER_IO_OPERATION_DATA));

lpPerIOData->Buffer.len = MSGSIZE;

lpPerIOData->Buffer.buf =lpPerIOData->szMessage;

lpPerIOData->sClient =g_sNewClientConnection;

WSARecv(lpPerIOData->sClient,

&lpPerIOData->Buffer,

1,

&lpPerIOData->NumberOfBytesRecvd,

&lpPerIOData->Flags,

&lpPerIOData->overlap,

CompletionRoutine);

g_bNewConnectionArrived = FALSE;

}

SleepEx(1000, TRUE);

}

return 0;

}

voidCALLBACK CompletionRoutine(DWORD dwError, DWORD cbTransferred, LPWSAOVERLAPPEDlpOverlapped, DWORD dwFlags)

{

LPPER_IO_OPERATION_DATA lpPerIOData =(LPPER_IO_OPERATION_DATA)lpOverlapped;

if (dwError != 0 || cbTransferred == 0)

{

// Connection was closed by client

closesocket(lpPerIOData->sClient);

HeapFree(GetProcessHeap(), 0,lpPerIOData);

}

else

{

lpPerIOData->szMessage[cbTransferred] ='\0';

send(lpPerIOData->sClient,lpPerIOData->szMessage, cbTransferred, 0);

// Launch another asynchronous operation

memset(&lpPerIOData->overlap, 0,sizeof(WSAOVERLAPPED));

lpPerIOData->Buffer.len = MSGSIZE;

lpPerIOData->Buffer.buf =lpPerIOData->szMessage;

WSARecv(lpPerIOData->sClient,

&lpPerIOData->Buffer,

1,

&lpPerIOData->NumberOfBytesRecvd,

&lpPerIOData->Flags,

&lpPerIOData->overlap,

CompletionRoutine);

}

}

用完成例程来实现重叠I/O比用事件通知简单得多。在这个模型中，主线程只用不停的接受连接即可；辅助线程判断有没有新的客户端连接被建立，如果有，就为那个客户端套接字激活一个异步的WSARecv操作，然后调用SleepEx使线程处于一种可警告的等待状态，以使得I/O完成后CompletionROUTINE可以被内核调用。如果辅助线程不调用SleepEx，则内核在完成一次I/O操作后，无法调用完成例程（因为完成例程的运行应该和当初激活WSARecv异步操作的代码在同一个线程之内）。

完成例程内的实现代码比较简单，它取出接收到的数据，然后将数据原封不动的发送给客户端，最后重新激活另一个WSARecv异步操作。注意，在这里用到了“尾随数据”。我们在调用WSARecv的时候，参数lpOverlapped实际上指向一个比它大得多的结构PER_IO_OPERATION_DATA，这个结构除了WSAOVERLAPPED以外，还被我们附加了缓冲区的结构信息，另外还包括客户端套接字等重要的信息。这样，在完成例程中通过参数lpOverlapped拿到的不仅仅是WSAOVERLAPPED结构，还有后边尾随的包含客户端套接字和接收数据缓冲区等重要信息。这样的C语言技巧在我后面介绍完成端口的时候还会使用到。