用IOCP实现个简易TCP并发服务器

我们前面接触过几个高效的unix/linux的异步IO模型:select,poll,epoll,kqueue,其实windows也有它的异步模型,比如windows版本的select,当然最高效的还属IOCP吧。我也没有做过多少windows的网络编程,但是看到网上不少人拿IOCP与epoll模型做对比,觉得必定不简单,忍不住试试。IOCP的原理大家多百度百度吧,我也还没弄清楚,呵呵。

大致核心原理是:我们不停地发出异步的WSASend/WSARecv IO操作,具体的IO处理过程由Windows系统完成,Windows系统完成实际的IO处理后,把结果送到完成端口上(如果有多个IO都完成了,那么在完成端口那里排成一个队列)。我们在另外一个线程里从完成端口不断取出IO操作结果,然后根据需要再发出WSASend/WSARecv IO操作。IO操作都放心地交给操作系统,我们只需要关注业务逻辑代码与监听完成端口的代码。下面是个简单的并发TCP服务器程序示例(程序下载地址:点击打开链接):

服务器端代码

#include<WinSock2.h>
#include<stdio.h>
#include<Windows.h>

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

#define PORT	1987		//监听端口
#define BUFSIZE 1024		//数据缓冲区大小

typedef struct 
{
	SOCKET s;				//套接字句柄
	sockaddr_in addr;		//对方的地址
} PER_HANDLE_DATA, *PPER_HANDLE_DATA;

typedef struct 
{
	OVERLAPPED ol;			//重叠结构
	char buf[BUFSIZE];		//数据缓冲区
	int nOperationType;		//操作类型
} PER_IO_DATA, *PPER_IO_DATA;

//自定义关注事件
#define OP_READ		100
#define OP_WRITE	200

DWORD WINAPI WorkerThread(LPVOID ComPortID)
{
	HANDLE cp = (HANDLE)ComPortID;

	DWORD	btf;
	PPER_IO_DATA pid;
    PPER_HANDLE_DATA phd;
    DWORD   SBytes, RBytes;
    DWORD   Flags;

	while(true)
	{
		//关联到完成端口的所有套接口等待IO准备好
		if(GetQueuedCompletionStatus(cp, &btf, (LPDWORD)&phd, 
			(LPOVERLAPPED *)&pid, WSA_INFINITE) == 0){
				return 0;
		}
	
		//当客户端关闭时会触发
		if(0 == btf && (pid->nOperationType == OP_READ || pid->nOperationType == OP_WRITE)) {
			closesocket(phd->s);

			GlobalFree(pid);
			GlobalFree(phd);

			printf("client closed\n");
			continue;
		}

		WSABUF buf;
		//判断IO端口的当前触发事件(读入or写出)
		switch(pid->nOperationType){
		case OP_READ:

			pid->buf[btf] = '\0';
			printf("Recv: %s\n", pid->buf);

			char sendbuf[BUFSIZE];
			sprintf(sendbuf,"Server Got \"%s\" from you",pid->buf);

			//继续投递写出的操作
			buf.buf = sendbuf;
			buf.len = strlen(sendbuf)+1;
			pid->nOperationType = OP_WRITE;

			SBytes = 0;

			//让操作系统异步输出吧
			WSASend(phd->s, &buf, 1, &SBytes, 0, &pid->ol, NULL);
			break;
		case OP_WRITE:

			pid->buf[btf] = '\0';
			printf("Send: Server Got \"%s\"\n\n", pid->buf);

			//继续投递读入的操作
			buf.buf = pid->buf;
			buf.len = BUFSIZE;
			pid->nOperationType = OP_READ;

			RBytes = 0;
			Flags = 0;

			//让底层线程池异步读入吧
			WSARecv(phd->s, &buf, 1, &RBytes, &Flags, &pid->ol, NULL);
			break;
		}
	}

	return 0;
}

void main()
{
	WSADATA wsaData;

	/*
	* 加载指定版本的socket库文件
	*/
	WSAStartup( MAKEWORD( 2, 2 ), &wsaData );
	printf("server start running\n");

	//创建一个IO完成端口
	HANDLE completionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);


	//创建一个工作线程,传递完成端口
	CreateThread(NULL, 0, WorkerThread, completionPort, 0, 0);

	/*
	* 初始化网络套接口
	*/
	SOCKET sockSrv=socket(AF_INET,SOCK_STREAM,0);
	SOCKADDR_IN addrSrv;
	addrSrv.sin_addr.S_un.S_addr=htonl(INADDR_ANY);
	addrSrv.sin_family=AF_INET;
	addrSrv.sin_port=htons(PORT);
		
	bind(sockSrv,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));

	listen(sockSrv,5);

	/*
	* 等待通信
	*/
	while (1)
	{
		SOCKADDR_IN  addrClient;
		int len=sizeof(SOCKADDR);

		SOCKET sockConn=accept(sockSrv,(SOCKADDR*)&addrClient,&len);

		//为新连接创建一个handle,关联到完成端口对象
		PPER_HANDLE_DATA phd = (PPER_HANDLE_DATA)GlobalAlloc(GPTR, sizeof(PER_HANDLE_DATA));
		phd->s = sockConn;
		memcpy(&phd->addr, &addrClient, len);

		CreateIoCompletionPort((HANDLE)phd->s, completionPort,(DWORD)phd, 0);

		//分配读写
		PPER_IO_DATA pid = (PPER_IO_DATA)GlobalAlloc(GPTR, sizeof(PER_IO_DATA));

		ZeroMemory(&(pid->ol), sizeof(OVERLAPPED));

		//初次投递读入的操作,让操作系统的线程池去关注IO端口的数据接收吧
		pid->nOperationType = OP_READ;
		WSABUF buf;
		buf.buf = pid->buf;
		buf.len = BUFSIZE;
		DWORD dRecv = 0;
		DWORD dFlag = 0;
		
		//一般服务器都是被动接受客户端连接,所以只需要异步Recv即可
		WSARecv(phd->s, &buf, 1, &dRecv, &dFlag, &pid->ol, NULL);
	}
}

客户端代码

#include<WinSock2.h>
#include<stdio.h>
#pragma comment(lib,"ws2_32.lib")

void main()
{
	WORD wVersionRequested;
	WSADATA wsaData;
	int err;

	/*
	* 加载指定版本的socket库文件
	*/
	wVersionRequested = MAKEWORD( 2, 2 );
	err = WSAStartup( wVersionRequested, &wsaData );
	if ( err != 0 ) {
		return;
	}

	/*
	* 初始化网络套接口
	*/
	SOCKET sockClient=socket(AF_INET,SOCK_STREAM,0);


	SOCKADDR_IN addrSrv;
	addrSrv.sin_addr.S_un.S_addr=inet_addr("127.0.0.1");
	addrSrv.sin_family=AF_INET;
	addrSrv.sin_port=htons(1987);
	
	connect(sockClient,(SOCKADDR *)&addrSrv,sizeof(SOCKADDR));

	/*
	* 通信
	*/
	char recvBuffer[100];

	//发送第一段消息
	printf("Send: %s\n","This is Kary");
	send(sockClient,"This is Kary",strlen("This is Kary")+1,0);
	recv(sockClient,recvBuffer,100,0);
	printf("Get: %s\n",recvBuffer);

	printf("\n");

	//发送第二段消息
	printf("Send: %s\n","Nice to meet you");
	send(sockClient,"Nice to meet you",strlen("Nice to meet you")+1,0);
	recv(sockClient,recvBuffer,100,0);
	printf("Get: %s\n",recvBuffer);

	closesocket(sockClient);

	WSACleanup();
	system("pause");
}

分别运行服务器端代码与客户端代码可以看到如下结果:

客户端命令行

Send: This is Kary
Get: Server Got "This is Kary" from you

Send: Nice to meet you
Get: Server Got "Nice to meet you" from you
请按任意键继续. . .
服务器端命令行

server start running
Recv: This is Kary
Send: Server Got "This is Kary"

Recv: Nice to meet you
Send: Server Got "Nice to meet you"

client closed
从上面繁杂的代码还是能感觉到windows网络编程是件多么苦逼的事情啊,IOCP虽然用到了windows底层的线程池专门去做异步IO,但是感觉远没有epoll编程直观,编码难度提升不少。不止是C语言,另外C#等基于.net框架的语言也有IOCP的接口支持,我没有尝试过。

IOCP的编码流程大致如下:

1,创建一个完成端口

2,创建一个工作线程

3,工作线程循环调用GetQueuedCompletionStatus()函数得到IO操作结果,这个函数是阻塞函数。

4,工作线程循环调用accept函数等待客户端连接

5,工作线程获取到新连接的套接字句柄用CreateIoCompletionPort函数关联到第一步创建的完成端口,然后发出一个异步的WSASend或者WSARecv调用,因为是异步调用,会立马返回,实际的发送接收数据操作由Windows系统去做。

6,工作线程继续下一次循环,阻塞accept等待客户端连接

7,Windows系统完成WSASend或者WSARecv的操作,把结果发到完成端口。

8,主线程的GetQueuedCompletionStatus马上返回,并从完成端口取得刚刚完成的WSASend或WSARecv的结果。

9,在主线程里对这些数据进行处理。(如果处理很耗时,需要新开线程处理),然后接着发WSASend/WSARecv,并继续下一次循环阻塞在GetQueuedCompletionStatus这里。

©️2020 CSDN 皮肤主题: 大白 设计师: CSDN官方博客 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值