IO完成端口入门级详细注释代码

#include "StdAfx.h"
#include "MyServer.h"
#include <WinSock2.h>

#pragma comment(lib, "Ws2_32.lib")//windows socket库

typedef struct __ARG
{
	HANDLE hComplete;
	SOCKET server;
}__ARG;

typedef struct CompleteKey
{
	SOCKET socket;
}CompleteKey;

//overlap一定要放在第一位置
typedef struct
{
	OVERLAPPED      overlap;       //重叠io必须的结构体
	WSABUF          buf;         //系统缓冲区指针	
	char            data[1024];//数据缓存区
	DWORD           NumberOfBytesRecvd;//发送或者接收的数据字节数
	DWORD           Flags;
	int OperationType;//操作类型
}IO_DATA;    //定义一个结构体保存IO数据

void initIoData(IO_DATA* ioData)//初始化io数据包
{
	memset(ioData,0,sizeof(IO_DATA));	
	ioData->buf.buf=ioData->data;
	ioData->buf.len=100;
	ioData->Flags=0;
	
	ioData->NumberOfBytesRecvd=100;
}

//弹出对话框
void myBox(char* format,...)
{
	char buf[100]={0};
	va_list ap;
	va_start(ap, format);
	sprintf_s(buf,format, ap);
	va_end(ap);
	MessageBoxA(0,buf,"",MB_OK);
}

//测试用函数
void test(SOCKET socket)
{
	char buf[100]={0};
	recv(socket,buf,100,0);
	myBox(buf);
}

//创建一个IO完成端口
HANDLE CreateNewCompletionPort(DWORD dwNumberOfConcurrentThreads)
{
	return( CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, NULL, dwNumberOfConcurrentThreads));
}

//将设备与完成端口管理起来
BOOL AssociateDeviceWithCompletionPort(HANDLE hCompletionPort, HANDLE hDevice,  DWORD dwCompletionKey) 
{
	HANDLE h = CreateIoCompletionPort(hDevice,   hCompletionPort, dwCompletionKey,   0);
	return(h == hCompletionPort);
}

//初始化winsock环境
void initSocket()
{
	WORD wVersionRequested;
	WSADATA wsaData;
	int err;
	wVersionRequested = MAKEWORD(2, 2);

	err = WSAStartup(wVersionRequested, &wsaData);
	if (err != 0) {
		printf("WSAStartup failed with error: %d\n", err);
		return ;
	}
	if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2) {
		printf("Could not find a usable version of Winsock.dll\n");
		WSACleanup();
		return ;
	}
}

MyServer::MyServer(void)
{
	//跟客户端端一样 初始化windows socket环境
	initSocket();

	//创建socket句柄	
	socksrv = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if(socksrv==INVALID_SOCKET)
	{
		myBox("create socket server error!");
	}

	//地址设定
	addrsrv.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
	addrsrv.sin_family = AF_INET;
	//端口设定
	addrsrv.sin_port = htons(9999);

	//绑定地址和端口
	bind(socksrv,(sockaddr*)&addrsrv,sizeof(sockaddr));

	//监听客户端请求
	listen(socksrv,5);
}

MyServer::~MyServer(void)
{

}

//服务器工作线程
DWORD WINAPI ServerWorkerThread(LPVOID arg) 
{
//	myBox("working\n");
	IO_DATA *data=0;	
	CompleteKey *key=0;
	DWORD recved;

	initSocket();
	while(1)
	{
		//异步接收的时候，传的是结构体中overlap的地址，这个地址和io_data结构体的地址是一致的 正是利用了这点，才巧妙的实现了异步获取数据
		//data返回的指针即为异步接收的时候传入的指针
		//key返回的指针即为绑定设备时候传入的指针
		GetQueuedCompletionStatus((HANDLE)arg,&recved,(LPDWORD)&key,(LPOVERLAPPED*)&data,WSA_INFINITE);
		
		//接收数据为0 说明客户端关闭连接
		if(recved==0)
		{
			closesocket(key->socket);
			delete key;
			GlobalFree(data);
			continue;
		}
		
		data->data[data->NumberOfBytesRecvd]=0;
		
		//讲数据不改动的发送给客户端
		send(key->socket,data->data,data->NumberOfBytesRecvd,0);

		initIoData(data);//初始化IO数据包

		//处理完数据后再次触发一次异步接收
		WSARecv(key->socket,&data->buf,1, &data->NumberOfBytesRecvd, &data->Flags,&data->overlap, NULL) ;
	}
	return 0;
}


//接收请求的线程
DWORD WINAPI MainThread(LPVOID arg) 
{
	__ARG *args=(__ARG*)arg;
	SOCKET client;
	initSocket();
	while(1)
	{
		SOCKADDR_IN saRemote;
		int nRemoteLen = sizeof(saRemote);

		//接受一个连接请求
		client= accept(args->server, (sockaddr*)&saRemote, &nRemoteLen);
		
		if(client==SOCKET_ERROR)
		{
			myBox("client error!\n");
			break;
		}

		//创建一个完成键
		CompleteKey* key=new CompleteKey();
		key->socket=client;
		
		//把接收到的客户socket当成设备管理到完成端口
		//key   标识这个设备的一些数据  		
		if(AssociateDeviceWithCompletionPort(args->hComplete,(HANDLE)client,(DWORD)key)==FALSE)//关联设备
			myBox("设备关联失败!");
		
		IO_DATA *ioData = (IO_DATA *)GlobalAlloc(GPTR,sizeof(IO_DATA));//初始化一个io完成数据
		
		initIoData(ioData);		
		
		//test(client);

		//触发一个异步接收请求  该函数调用后立马返回
		int ret=WSARecv(client,&ioData->buf,1, &ioData->NumberOfBytesRecvd, &ioData->Flags,&ioData->overlap, NULL) ;

		//注意多判断一个错误码~  如果错误码是WSA_IO_PENDING 其实也是正常状态，因为
		//该错误码表明异步操作成功，等待指示。（客户端调用connect后被阻塞了，就会出现这种情况）
		if(ret==SOCKET_ERROR && WSAGetLastError()!=WSA_IO_PENDING)			
		{
			myBox("wsaRecv error :%d \n",WSAGetLastError());	
		}			
	}
	return 0;
}




void MyServer::begin()
{
	int threads=2;
	HANDLE hCompletion = CreateNewCompletionPort(threads);//创建两个工作线程
	if(hCompletion==0)
	{
		myBox("端口创建失败！");
		return;
	}
	int i=0;
	DWORD threadId;
	for(i=0;i<threads;i++)
	{
		CreateThread(0,0,ServerWorkerThread,hCompletion,0,&threadId);
	}
	__ARG *arg=new __ARG();
	arg->hComplete=hCompletion;
	arg->server=socksrv;

	CreateThread(0,0,MainThread,arg,0,&threadId);
}