c/c++ TcpServer-IOCP管理模式

IOCP

1: IOCP: 是windows针对高性能服务器做的IO的管理模式，又叫完成端口;

2: IOCP的核心模式:

1>提交请求;

2>等待结果;

3>继续提交请求;

3: 监听:

1>提交一个监听请求,使用完成端口来等待这个请求到来;

2>请求来了后，处理，继续提交请求;

4: 读取数据:

1>提交一个读取数据的请求。

2>请求完成后，处理完后继续提交;

5: 发送数据的请求:

1>提交一个发送数据的请求;

2>请求完成后，继续处理;

IOCP开发

1:配置IOCP开发环境:

#include <WinSock2.h>
#include <mswsock.h>
#include <windows.h>
#pragma comment(lib, "WSOCK32.lib ")
#pragma comment(lib, "ws2_32.lib")
#pragma comment(lib, "odbc32.lib")
#pragma comment(lib, "odbccp32.lib")

2: 创建一个IOCP;

3: 提交一个IOCP的监听请求:

4: 提交读请求;

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
/*
IOCP 只支持windows平台 Linux epoll
*/
#include <WinSock2.h>
#include <MSWSock.h>
#include <Windows.h>

#pragma comment(lib,"WSOCK32.LIB")
#pragma comment(lib,"ws2_32.lib")
#pragma comment(lib,"odbc32.lib")
#pragma comment(lib,"odbccp32.lib")

// 非常重要的数据结构;
enum{
IOCP_ACCEPT = 0, // 监听socket,接入请求;
IOCP_RECV, // 读请求;
IOCP_WRITE, // 写请求;
};

// 接收数据的时候最大的buf大小;
#define MAX_RECV_SIZE 8192

struct io_package{
// 自己定义的, 一定要在第一个就要用WSAOVERLAPPED 结构体;?
// 所有的请求的等待，都是等在这个结构对象上的，必须是第一个;
WSAOVERLAPPED overlapped;

// 操作类型, 监听,读,写, IOCP_ACCPET, IOCP_RECV, IOCP_WRITE
int opt;

// 句柄,就是我们提交请求的句柄, accept的句柄或你读写请求的句柄
int accept_sock;

// 结构体，配合读写数据的时候用的bufffer;
WSABUF wsabuffer;// wsabuffer.buf = 内存;, wsabuffer.len = MAX_RECV_SIZE;

// 定义了一个buf,这个buf就是整正的内存;
char pkg[MAX_RECV_SIZE];
};

// 投递一个用户的请求;
static void post_accept(SOCKET l_sock){
// step1: 分配一个io_package 数据结构;
struct io_package* pkg = malloc(sizeof(struct io_package));
memset(pkg, 0, sizeof(struct io_package));

// 初始化好了接受数据的buf --> WSABUF
pkg->opt = IOCP_ACCEPT; // 请求类型;
pkg->wsabuffer.buf = pkg->pkg;
pkg->wsabuffer.len = MAX_RECV_SIZE - 1;

SOCKET client = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
int addr_size = (sizeof(struct sockaddr) + 16);
pkg->accept_sock = client;// 创建一个socket,然后客户端连接进来后，就用这个socket和我们的客户端通讯;

// 发送一个异步的请求，来接入客户端的连接;
DWORD dwBytes = 0;
AcceptEx(l_sock, client, pkg->wsabuffer.buf, 0,
addr_size, addr_size, &dwBytes, &pkg->overlapped);

}

static void post_recv(SOCKET client_fd){
struct io_package* io_data = malloc(sizeof(struct io_package));
memset(io_data, 0, sizeof(struct io_package));

io_data->opt = IOCP_RECV;
io_data->wsabuffer.buf=io_data->pkg;
io_data->wsabuffer.len = MAX_RECV_SIZE - 1;
io_data->accept_sock = client_fd;

DWORD dwRecv = 0;
DWORD dwFlgs = 0;
int ret = WSARecv(client_fd, &(io_data->wsabuffer), 1,
&dwRecv, &dwFlgs,&(io_data->overlapped),NULL );
}

int main(int argc, char** argv){
// 如果你做socket那么必须要加上;
WSADATA data;
WSAStartup(MAKEWORD(2, 2), &data);

// step1:创建一个完成端口;
HANDLE  iocp = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
if (iocp == INVALID_HANDLE_VALUE){
goto failed;
}

// 创建我们的监听socket,开始监听
SOCKET l_sock = INVALID_SOCKET;
l_sock = socket(AF_INET, SOCK_STREAM, 0);
if (l_sock == INVALID_SOCKET){
goto failed;
}
struct sockaddr_in s_address;
memset(&s_address, 0, sizeof(s_address));
s_address.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
s_address.sin_family = AF_INET;
s_address.sin_port = htons(6080);
if (bind(l_sock, (struct sockaddr*)&s_address, sizeof(s_address)) != 0){
goto failed;
}
if (listen(l_sock, SOMAXCONN) != 0){
goto failed;
}

// 让IOCP来管理我们的l_sock
// 第三个参数，是用户传的自定义数据(一个指针带入进去),后面讲解;
CreateIoCompletionPort((HANDLE)l_sock, iocp, (DWORD)0, 0);

// 发送一个监听用户进来的请求;
post_accept(l_sock);// 投递一个accpet接入请求;

while (1){
DWORD dwTrans;
DWORD udata;
struct io_package* io_data;
// 通过完成端口，来获得这个请求的结果;
// 调用操作系统的API函数，查看，那个请求完成了;
// 如果没有状态完成了,那么任务会挂起，等待;
int ret = GetQueuedCompletionStatus(iocp,&dwTrans,
&udata,(LPOVERLAPPED*)&io_data,WSA_INFINITE);
if (ret == 0){ //意外
if (io_data){
if (io_data->opt == IOCP_RECV){
closesocket(io_data->accept_sock);
free(io_data);
}
else if (io_data->opt == IOCP_ACCEPT){
free(io_data);
post_accept(l_sock);
}
}
continue;
}
if (dwTrans == 0 && io_data->opt == IOCP_RECV){
// 关闭socket发生了;
closesocket(io_data->accept_sock);
free(io_data);
continue;
}
switch (io_data->opt)
{
case IOCP_ACCEPT: //接入第一个SOCKET;
{
//接入的client_sock
int client_fd = io_data->accept_sock;
int addr_size = (sizeof(struct sockaddr_in) + 16);
struct sockaddr_in* l_addr = NULL;
int l_len = sizeof(struct sockaddr_in);
struct sockaddr_in* r_addr = NULL;
int r_len = sizeof(struct sockaddr_in);

GetAcceptExSockaddrs(io_data->wsabuffer.buf, 0,/*io_data->wsabuffer.len - addr_size * 2, */
addr_size, addr_size,
(struct sockaddr**)&l_addr, &l_len,
(struct sockaddr**)&r_addr,&r_len);

// 将新进来的client_fd,也加入完成端口，来帮助管理完成的请求;
// 第三个参数是用户自定义数据，你可以携带自己的数据结构，client_fd;
CreateIoCompletionPort((HANDLE)client_fd, iocp, (DWORD)client_fd, 0);
//投递一个读的请求
post_recv(client_fd);
//重新投递一个接入客户端
free(io_data);
post_accept(l_sock);
}
break;
case IOCP_RECV:
{
//dwTrans 读到数据的大小；
//soket,io_data->accept_sock;
//Buf io_data->wsabuffer.buf
io_data->pkg[dwTrans] = 0;
printf("IOCP RECV %d %s\n", dwTrans, io_data->pkg);
send(io_data->accept_sock, io_data->pkg, dwTrans, 0);

//再来投递下一个请求
DWORD dwRecv = 0;
DWORD dwFlgs = 0;
int ret = WSARecv(io_data->accept_sock, &(io_data->wsabuffer),
1, &dwRecv, &dwFlgs, &(io_data->overlapped),NULL);
}
break;
default:
break;
}
}

failed:
if (l_sock){
goto failed;
}
if (iocp != INVALID_HANDLE_VALUE){
CloseHandle(iocp);//释放关闭端口
}

WSACleanup();
return 0;
}

服务端

客户端