iocp的简单实现

最新推荐文章于 2021-06-15 14:28:34 发布
最新推荐文章于 2021-06-15 14:28:34 发布
阅读量962 收藏 2
点赞数
分类专栏： 网络通讯 文章标签： iocp 多线程 单例 面向对象 标准模板库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/xilango/article/details/79198712
版权

本文借助炽离的winsock编程IOCP模型实现代码进行进一步分析以及扩展。

本文主要使用到了以下几个知识点，1.标准模板库（stl）使用 2.多线程的使用3.单例等设计模式4.socket网络通讯5.面向对象的编程思想，适用于初学iocp的同学。

一：简单的iocp，我们主要分为以下几个类。大家不要急着看代码，先可以通过以下的模块试着编写以下

类

描述

CThreadLockCs

防止同一时间，多条线程对同一操作，同时执行。

CSingleton<T>

单例模式，这是一个模板类，利用单例模式生成唯一对象。

COverlappedIOInfo

对Overlapped进行封装，主要作用是将自己所需要的数据进行绑定

CIOCP

对iocp进行封装

CTaskService

线程服务，用于线程的管理。

CServer 

服务器核心，创建socket，投递操作，处理完成消息等。

二：各类的成员简介

类名：CThreadLockCs

继承：

父类：

成员

权限

变量名

描述

private

CRITICAL_SHCTLON  m_cs

临界区对象

public

CThreadLockCs()

构造函数，初始化临界区对象

public

~CThreadLockCs()

析构函数，释放临界区对象

public

Void lock()

临界区入口

public

Void unlock

临界区出口

 

类名：CSingleton<T>

继承：

父类：

成员

权限

变量名

描述

private

Static T* _Instance

利用本类生成的对象

private

CSingleton

构造函数，对成员初始化

private

Static CThreadLockCs  Ics

临界区对象

public

Static T* Instance

生成对象

public

Void Close()

释放对象

 

类名：COverlappedIOinfo

继承：public

父类：Overlapped

成员

权限

变量名

描述

public

SOCKET    m_sScost

用于通讯的套接字

public

WSABUF   m_recvBuf

接收缓存区

public

Char      m_crecvBuf

接收缓存区

public

WSABUF   m_sendBuf

发送缓存区

public

Char      m_csendBuf

发送缓存区

public

Sockaddr   m_addr

对端地址

public

COverlappedIOinfo()

构造函数初始化套接字和复位

public

~COverlappedIOinfo()

析构函数关闭套接字

public

VoidResetOverlapped()

复位Overlapped

public

VoidResetRecvBuffer()

复位RecvBuffer

public

Void ResetSendBuffed()

复位SendBuffer


 

类名：CIOCP

继承：

父类：

成员

权限

变量名

描述

private

HANDLE m_hIOCP

完成端口句柄

public

CIOCP(int nMaxConcurrency=-1)

构造函数，初始化完成端口句柄，并创建完成端口。

public

~CIOCP()

析构函数，关闭完成端口。

public

BoolCreateIOCP(int nMaxConcurrency = 0);

创建完成端口，并指定最大并发线程数量。

public

Bool  CloseIOCP()

关闭完成端口

public

bool AsscciateDevice(HANDLE hDevice,ULONG_PTR CompKey)

为设备关联一个完成端口

public

bool AsscciateScoket(SOCKET hSocket,ULONG_PTR CompKey);

将套接字关联一个完成端口

public

bool PostStatus(ULONG_PTR CompKey,DWORD dwNumBytes = 0,OVERLAPPED* po =NULL);

添加一个完成端口io操作

public

bool GetStatus(ULONG_PTR* pCompKey, PDWORD pdwNumBytes,OVERLAPPED** ppo,DWORD dwMilliseconds =INFINITE);

从完成队列中获取io通知

public

constHANDLE  GetIOCP();

获取iocp对象

 

 

类名：CTaskService

继承：

父类：

成员

权限

变量名

描述

private

staticUINT WorkThread(LPVOID param);

工作线程访问接口

private

std::vector<CWinThread*>    vec_threads;

线程队列

public

UINT    Activate(int num = 1);

用于激活一定数量的工作线程

public

UINT    GetThreadsNum(void);

获取线程数目

protected

CTaskService(void);

构造函数，只能用于子类

protected

~CTaskService(void);

析构函数

protected

virtual void svc();

子类对线程函数进行重写

protected

VoidClose();

退出线程，由子类决定

类名：Cserver

继承：public

父类：CTaskService

成员

权限

变量名

描述

private

WSAData     m_wsaData

winsock版本类型

private

SOCKET     m_sListen

监听socket

private

std::vector<SOCKET> m_vecAcps

等待accept的socket

private

std::vector<COverlappedIOInfo*>    m_vecContInfo;

已建立连接的信息

private

CThreadLockCs  m_lsc;

互斥同步

private

CIOCP          m_iocp;

Icop封装

private

LPFN_ACCEPTEX  m_lpfnAcceptEx;

AcceptEx函数指针

private

LPFN_GETACCEPTEXSOCKADDRS    m_lpfnGetAcceptSockAddrs

GetAcceptSockAddrs函数指针

public

Cserver()

初始化函数指针获取版本类型

public

~Cserver()

对套接字 线程等资源释放 并终止Winsock 2 DLL (Ws2_32.dll)的使用

public

bool StartListen(unsigned short port,std::string ip)

创建监听socket，创建完成端口并将完成端口与监听socket绑定，获取AcceptEx与GetAcceptSockAddrs函数指针 启动工作线程，投递accept操作

private

UINT    StartThreadPull()

获取计算机cpu数目，并创建启动工作线程

private

Bool GetLPFNAcceptEXAndGetAcceptSockAddrs()

获取AcceptEx和GetAcceptSockAddrs函数指针

private

Bool PostAccept(COverlappedIOInfo* ol)

创建一个连接socket，设置COverlappedIOInfo，并开始进行事件监听（投递accept）

private

Bool DoAccept(COverlappedIOInfo* ol, DWORD NumberOfBytes = 0)

 

处理accept请求

private

bool PostRecv(COverlappedIOInfo* ol)

投递recv请求

private

bool DoRecv(COverlappedIOInfo* ol)

处理recv请求

private

bool DeleteLink(SOCKET s)

从已连接socket列表中移除socket及释放空间

private

void CloseServer()

对套接字 线程等资源释放 

protected

virtual void svc();

工作线程函数

三：代码实现

       1. CSingleton.h
  
#ifndef  CSINGLETON_H
#define  CSINGLETON_H
#pragma once
//互斥访问锁
class CThreadLockCs
{
public:
	//此函数初始化一个临界区对象。
	CThreadLockCs() { InitializeCriticalSection(&m_cs); }
	//删除临界区对象
	~CThreadLockCs() { DeleteCriticalSection(&m_cs); }
	//加锁接下来的代码处理过程不允许其他线程同时操作
	void lock() { EnterCriticalSection(&m_cs); }
	//解锁解锁 到EnterCriticalSection之间代码资源已经释放了，其他线程可以进行操作  
	void unlock() { LeaveCriticalSection(&m_cs); }
private:
	//临界区对象
	CRITICAL_SECTION m_cs;
};
/************************************************************************
singleton模式类模板
1:延迟创建类实例    2:double check    3:互斥访问    4:模板
************************************************************************/


template<class T>
class CSingleton
{
private:
	static T* _instance;
	CSingleton(void);
	static CThreadLockCs lcs;
public:
	static T* Instance(void);
	static void Close(void);
};

//模板类static变量
template<class T>
T*  CSingleton<T>::_instance = NULL;

template<class T>
CThreadLockCs CSingleton<T>::lcs;

//模板类方法实现
template<class T>
CSingleton<T>::CSingleton(void)
{

}

template<class T>
T*  CSingleton<T>::Instance(void)
{
	//double-check
	//延迟创建，只有调用方访问Instance才会创建类实例
	if (_instance == NULL)
	{
		//互斥访问锁，用CriticalSection实现
		lcs.lock();
		if (_instance == NULL)
		{
			_instance = new T;
		}
		lcs.unlock();
	}
	return _instance;
}

template<class T>
void CSingleton<T>::Close(void)
{
	if (_instance)
	{
		delete _instance;
	}
}
#endif
2.OverlappedIOInfo.h
  
#ifndef OVERLAPPEDIOINFO_H
#define OVERLAPPEDIOINFO_H

#pragma once
#include <WinSock2.h>
#include <MSWSock.h>
#define  MAXBUF               1024*8
/******************************************************************************
Module:  OverlappedIOInfo.h
Notices: Copyright (c) 20161201  whg
Purpose:
IOCP网络编程模型中，需要用到GetQueuedCompletionStatus函数获取已完成事件。
但该函数的返回参数无socket或buffer的描述信息。

一个简单的解决办法，创建一个新的结构，该结构第一个参数是OVERLAPPED。
由于AcceptEx、WSASend等重叠IO操作传入的是Overlapped结构体的地址，调用AcceptEx等重叠IO操作，
在Overlapped结构体后面开辟新的空间，写入socket或buffer的信息，即可将socket或buffer的信息由
GetQueuedCompletionStatus带回。

参考《windows核心编程》和优快云 PiggyXP
******************************************************************************/
enum IOOperType {
	TYPE_ACP,            //accept事件到达，有新连接请求    
	TYPE_RECV,           //数据接收事件
	TYPE_SEND,           //数据发送事件
	TYPE_CLOSE,          //关闭事件
	TYPE_NO_OPER
};
class COverlappedIOInfo:public OVERLAPPED
{
public:
	
	SOCKET          m_sSocket;                 //套接字
	
	WSABUF          m_recvBuf;               //接收缓冲区，用于AcceptEx、WSARecv操作
	char            m_cRecvBuf[MAXBUF];        
	
	WSABUF          m_sendBuf;               //发送缓冲区，用于WSASend操作
	char            m_cSendBuf[MAXBUF];
	
	sockaddr_in     m_addr;                  //对端地址
public:
	COverlappedIOInfo();
	~COverlappedIOInfo();
	//复位Overlapped
	void ResetOverlapped();
	//复位RecvBuffer
	void ResetRecvBuffer();
	//复位SendBuffer
	void ResetSendBuffer();
};
#endif // !OVERLAPPEDIOINFO_H
3.OverlappedIOInfo.cpp 
#include "stdafx.h"
#include "OverlappedIOInfo.h"


COverlappedIOInfo::COverlappedIOInfo()
{
	m_sSocket = INVALID_SOCKET;
	ResetOverlapped();
	ResetRecvBuffer();
	ResetSendBuffer();
}


COverlappedIOInfo::~COverlappedIOInfo()
{
	if (m_sSocket != INVALID_SOCKET)
	{
		closesocket(m_sSocket);
		m_sSocket = INVALID_SOCKET;
	}
}
void COverlappedIOInfo::ResetOverlapped()
{
	Internal = InternalHigh = 0;
	Offset = OffsetHigh = 0;
	hEvent = NULL;
}
void COverlappedIOInfo::ResetRecvBuffer()
{
	ZeroMemory(m_cRecvBuf, MAXBUF);
	m_recvBuf.buf = m_cRecvBuf;
	m_recvBuf.len = MAXBUF;
}
void COverlappedIOInfo::ResetSendBuffer()
{
	ZeroMemory(m_cSendBuf, MAXBUF);
	m_sendBuf.buf = m_cSendBuf;
	m_sendBuf.len = MAXBUF;
}
4.CIOCP.h 

#ifndef CIOCP_H
#define CIOCP_H
#include <winsock2.h>
#include <MSWSock.h>
/******************************************************************************
Module:  IOCP.h
Notices: Copyright (c) 2007 Jeffrey Richter & Christophe Nasarre
Purpose: This class wraps an I/O Completion Port.
Revise:    IOCP封装类，由《windows核心编程》第10章示例程序源码改编所得
******************************************************************************/
#pragma once   

class CIOCP
{

private:
	
	HANDLE                          m_hIOCP;                       //IOCP句柄
public:
	CIOCP(int nMaxConcurrency = -1);
	~CIOCP();
	//创建IOCP，nMaxConcurrency指定最大线程并发数量，0默认为cpu数量
	bool CreateIOCP(int nMaxConcurrency = 0);

	//关闭IOCP
	bool CloseIOCP();

	//为设备关联一个IOCP
	bool AsscciateDevice(HANDLE hDevice, ULONG_PTR CompKey);

	//为socket关联一个IOCP
	bool AsscciateScoket(SOCKET hSocket, ULONG_PTR CompKey);
	//为iocp传递事件通知
	bool PostStatus(ULONG_PTR CompKey, DWORD dwNumBytes = 0, OVERLAPPED* po = NULL);

	//从IO完成队列中获取事件通知。IO完成队列无事件时，该函数将阻塞
	bool GetStatus(ULONG_PTR* pCompKey, PDWORD pdwNumBytes, OVERLAPPED** ppo, DWORD dwMilliseconds = INFINITE);

	//获取IOCP对象
	const HANDLE  GetIOCP();

};
5.CIOCP.cpp 
#endif // !CIOCP_H

#include "stdafx.h"
#include "CIOCP.h"

#ifdef _DEBUG
#define  ASSERT(T)        assert(T)
#else
#define  ASSERT(T)        (T)
#endif


CIOCP::CIOCP(int nMaxConcurrency)
{
	m_hIOCP = NULL;
	if (-1 != nMaxConcurrency)
	{
		CreateIOCP(nMaxConcurrency);
	}
}


CIOCP::~CIOCP()
{
	if (m_hIOCP != NULL)
		ASSERT(CloseHandle(m_hIOCP));
}
//创建IOCP，nMaxConcurrency指定最大线程并发数量，0默认为cpu数量
bool CIOCP::CreateIOCP(int nMaxConcurrency )
{   
	//创建一个完成端口
	m_hIOCP = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, nMaxConcurrency);
	//效验
	ASSERT(m_hIOCP != NULL);

	return (m_hIOCP != NULL);
}

//关闭IOCP
bool CIOCP::CloseIOCP()
{   
	//关闭完成端口
	bool bResult = CloseHandle(m_hIOCP);
	m_hIOCP = NULL;
	return(bResult);
}

//为设备关联一个IOCP
bool CIOCP::AsscciateDevice(HANDLE hDevice, ULONG_PTR CompKey)
{   //关联完成端口
	//1关联的设备句柄2完成端口句柄3需要绑定的结构体
	bool fOk = (CreateIoCompletionPort(hDevice, m_hIOCP, CompKey, 0) == m_hIOCP);
	//效验
	ASSERT(fOk);

	return(fOk);
}

//为socket关联一个IOCP
bool CIOCP::AsscciateScoket(SOCKET hSocket, ULONG_PTR CompKey)
{    
	return AsscciateDevice((HANDLE)hSocket, CompKey);
}
//为iocp传递事件通知
bool CIOCP::PostStatus(ULONG_PTR CompKey, DWORD dwNumBytes , OVERLAPPED* po)
{   
    //手动添加一个完成端口io操作
	bool fOk = PostQueuedCompletionStatus(m_hIOCP, dwNumBytes, CompKey, po);
	ASSERT(fOk);
	return(fOk);

}

//从IO完成队列中获取事件通知。IO完成队列无事件时，该函数将阻塞
bool CIOCP::GetStatus(ULONG_PTR* pCompKey, PDWORD pdwNumBytes, OVERLAPPED** ppo, DWORD dwMilliseconds)
{
	//监控完成端口
	//1 我们创建的完成端口 2操作完成后返回的字节数 3需要绑定的结构体 
	//4重叠结构LPOVERLAPPED 5等待完成端口的超时时间 
	return(GetQueuedCompletionStatus(m_hIOCP, pdwNumBytes, pCompKey, ppo, dwMilliseconds));
}

//获取IOCP对象
const HANDLE  CIOCP::GetIOCP()
{
	return m_hIOCP;
}



/ End of File /
6.TaskService.h 
#ifndef WHG_CTASKSVC
#define WHG_CTASKSVC
#include <vector>
#include <afxwin.h>
class CTaskService
{
public:
	//Activate用于激活一定数量的工作者线程，默认激活数量为1。返回当前线程队列大小
	UINT    Activate(int num = 1);
	//获取线程队列大小
	UINT    GetThreadsNum(void);

protected:
	//只有子类才可以构造父类，拒绝外部访问构造类实例
	CTaskService(void);
	~CTaskService(void);
	//子类应重定义工作线程细节
	virtual void svc();
	//Close用于等待线程结束并关闭线程，退出线程由子类控制
	void    Close();

private:
	//工作者线程访问接口
	static UINT WorkThread(LPVOID param);
	//线程队列
	std::vector<CWinThread*>    vec_threads;
};
#endif
7.TaskService.cpp 

#include "stdafx.h"
#include "TaskService.h"

CTaskService::CTaskService(void)
{
}

CTaskService::~CTaskService(void)
{
	Close();
}

UINT CTaskService::Activate(int num)
{
	for (int i = 0; i < num; i++)
	{
		CWinThread* pwt = AfxBeginThread(WorkThread, this, THREAD_PRIORITY_NORMAL, 0, CREATE_SUSPENDED);
		if (pwt)
		{
			pwt->m_bAutoDelete = false;
			pwt->ResumeThread();
			vec_threads.push_back(pwt);
		}
	}
	return vec_threads.size();
}

UINT CTaskService::GetThreadsNum(void)
{
	return vec_threads.size();
}


UINT CTaskService::WorkThread(LPVOID param)
{
	CTaskService* pts = (CTaskService*)param;
	if (pts)
	{
		pts->svc();
	}
	return 0;
}

void CTaskService::svc()
{

}

void CTaskService::Close()
{
	int cnt = vec_threads.size();
	if (cnt > 0)
	{
		std::vector<CWinThread*>::iterator iter = vec_threads.begin();
		for (; iter != vec_threads.end(); iter++)
		{
			CWinThread* pwt = *iter;
			WaitForSingleObject(pwt->m_hThread, INFINITE);
			delete pwt;
		}
		vec_threads.clear();
	}
}
8.Server.h 
#ifndef SERVER_H
#define SERVER_H
#pragma once
#include "TaskService.h"
#include "OverlappedIOInfo.h"
#include "CSingleton.h"
#include "CIOCP.h"
class CServer :public CTaskService
{
#define ACCEPT_SOCKET_NUM  10
private:
	
	WSAData                        m_wsaData;                   //winsock版本类型
	
	SOCKET                         m_sListen;                   //端口监听套接字
	
	std::vector<SOCKET>            m_vecAcps;                   //等待accept的套接字

	//已建立连接的信息，每个结构含有一个套接字、发送缓冲和接收缓冲，以及对端地址
	std::vector<COverlappedIOInfo*>    m_vecContInfo;
	//操作vector的互斥访问锁
	CThreadLockCs                m_lsc;
	//IOCP封装类
	CIOCP                        m_iocp;
	//AcceptEx函数指针
	LPFN_ACCEPTEX                m_lpfnAcceptEx;
	//GetAcceptSockAddrs函数指针
	LPFN_GETACCEPTEXSOCKADDRS    m_lpfnGetAcceptSockAddrs;
public:
	CServer(void);
	~CServer(void);
	bool    StartListen(unsigned short port, std::string ip);

protected:
	virtual void svc();

private:
	//启动CPU*2个线程，返回已启动线程个数
	UINT    StartThreadPull();
	//获取AcceptEx和GetAcceptExSockaddrs函数指针
	bool    GetLPFNAcceptEXAndGetAcceptSockAddrs();
	//利用AcceptEx监听accept请求
	bool    PostAccept(COverlappedIOInfo* ol);
	//处理accept请求,NumberOfBytes=0表示没有收到第一帧数据，>0表示收到第一帧数据
	bool    DoAccept(COverlappedIOInfo* ol, DWORD NumberOfBytes = 0);
	//投递recv请求
	bool    PostRecv(COverlappedIOInfo* ol);
	//处理recv请求
	bool    DoRecv(COverlappedIOInfo* ol);
	//从已连接socket列表中移除socket及释放空间
	bool    DeleteLink(SOCKET s);
	//释放3个部分步骤：
	//1：清空IOCP线程队列，退出线程
	//2: 清空等待accept的套接字m_vecAcps
	//3: 清空已连接的套接字m_vecContInfo并清空缓存
	void    CloseServer();

};

typedef CSingleton<CServer> SERVER;
#endif
9.Server.cpp
  
#include "stdafx.h"
#include "Server.h"


CServer::CServer()
{
	m_lpfnAcceptEx = NULL;
	m_lpfnGetAcceptSockAddrs = NULL;
	WSAStartup(MAKEWORD(2, 2), &m_wsaData);
	printf("%d\n", m_wsaData.iMaxSockets);
}


CServer::~CServer()
{
	CloseServer();
	WSACleanup();
}
bool CServer::StartListen(unsigned short port, std::string ip)
{   
	//listen socket需要将accept操作投递到完成端口，因此，listen socket属性必须有重叠IO
	m_sListen = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
	if (m_sListen == INVALID_SOCKET)
	{
		cout << "WSASocket create socket error" << endl;
		return false;
	}
	//创建并设置IOCP并发线程数量
	if (m_iocp.CreateIOCP() == FALSE)
	{
		cout << "IOCP create error,error code " << WSAGetLastError() << endl;
		return false;
	}
	//将listen socket绑定至iocp
	if (!m_iocp.AsscciateScoket(m_sListen, TYPE_ACP))
	{
		cout << "iocp Associate listen Socket error" << endl;
		return false;
	}
	sockaddr_in service;
	service.sin_family = AF_INET;
	service.sin_port = htons(port);
	if (ip.empty())
	{
		service.sin_addr.s_addr = INADDR_ANY;
	}
	else
	{
		service.sin_addr.s_addr = inet_addr(ip.c_str());
	}

	if (bind(m_sListen, (sockaddr*)&service, sizeof(service)) == SOCKET_ERROR)
	{
		cout << "bind() error,error code " << WSAGetLastError() << endl;
		return false;
	}
	cout << "bind ok!" << endl;

	if (listen(m_sListen, SOMAXCONN) == SOCKET_ERROR)
	{
		cout << "listen() error,error code " << WSAGetLastError() << endl;
		return false;
	}
	cout << "listen ok!" << endl;
	//启动工作者线程
	int threadnum = StartThreadPull();
	cout << "启动工作者线程,num=" << threadnum << endl;
	//获取AcceptEx和GetAcceptSockAddrs函数指针
	if (!GetLPFNAcceptEXAndGetAcceptSockAddrs())
	{
		return false;
	}
	//创建10个acceptex
	for (int i = 0; i < ACCEPT_SOCKET_NUM; i++)
	{
		//用accept
		COverlappedIOInfo* ol = new COverlappedIOInfo;
		if (!PostAccept(ol))
		{
			delete ol;
			return false;
		}
	}

}
void CServer::svc()
{
	while (true)
	{
		DWORD  NumberOfBytes = 0;
		unsigned long CompletionKey = 0;
		OVERLAPPED*    ol = NULL;
		if (FALSE != GetQueuedCompletionStatus(m_iocp.GetIOCP(), &NumberOfBytes, &CompletionKey, &ol, WSA_INFINITE))
		{
			COverlappedIOInfo* olinfo = (COverlappedIOInfo*)ol;

			if (CompletionKey == TYPE_CLOSE)
			{
				break;
			}
			if (NumberOfBytes == 0 && (CompletionKey == TYPE_RECV || CompletionKey == TYPE_SEND))
			{
				//客户端断开连接
				cout << "客户端断开连接,ip=" << inet_ntoa(olinfo->m_addr.sin_addr) << ",port=" << olinfo->m_addr.sin_port << endl;
				DeleteLink(olinfo->m_sSocket);
				continue;
			}
			
			switch (CompletionKey)
			{
			case TYPE_ACP:
			{
				DoAccept(olinfo, NumberOfBytes);
				PostAccept(olinfo);
			}
			break;
			case TYPE_RECV:
			{
				DoRecv(olinfo);
				PostRecv(olinfo);
			}
			break;
			case TYPE_SEND:
			{
			}
			break;
			default:
				break;
			}
		}
		else
		{
			int res = WSAGetLastError();
			switch (res)
			{
			case ERROR_NETNAME_DELETED:
			{
				COverlappedIOInfo* olinfo = (COverlappedIOInfo*)ol;
				if (olinfo)
				{
					cout << "客户端异常退出,ip=" << inet_ntoa(olinfo->m_addr.sin_addr) << ",port=" << olinfo->m_addr.sin_port << endl;
					DeleteLink(olinfo->m_sSocket);
				}
			}
			break;
			default:
				cout << "workthread GetQueuedCompletionStatus error,error code " << WSAGetLastError() << endl;
				break;
			}
			continue;
		}
	}
	cout << "workthread stop" << endl;
}
//启动CPU*2个线程，返回已启动线程个数
UINT   CServer::StartThreadPull()
{   
	//获取系统cpu个数启动线程
	SYSTEM_INFO si;
	GetSystemInfo(&si);
	//启动cpu数量*2个线程
	return Activate(si.dwNumberOfProcessors * 2);

}
//获取AcceptEx和GetAcceptExSockaddrs函数指针
bool   CServer::GetLPFNAcceptEXAndGetAcceptSockAddrs()
{
	DWORD BytesReturned = 0;
	//获取AcceptEx函数指针
	GUID GuidAcceptEx = WSAID_ACCEPTEX;
	if (SOCKET_ERROR == WSAIoctl(
		m_sListen,
		SIO_GET_EXTENSION_FUNCTION_POINTER,
		&GuidAcceptEx,
		sizeof(GuidAcceptEx),
		&m_lpfnAcceptEx,
		sizeof(m_lpfnAcceptEx),
		&BytesReturned,
		NULL, NULL))
	{
		cout << "WSAIoctl get AcceptEx function error,error code " << WSAGetLastError() << endl;
		return false;
	}

	//获取GetAcceptexSockAddrs函数指针
	GUID GuidGetAcceptexSockAddrs = WSAID_GETACCEPTEXSOCKADDRS;
	if (SOCKET_ERROR == WSAIoctl(
		m_sListen,
		SIO_GET_EXTENSION_FUNCTION_POINTER,
		&GuidGetAcceptexSockAddrs,
		sizeof(GuidGetAcceptexSockAddrs),
		&m_lpfnGetAcceptSockAddrs,
		sizeof(m_lpfnGetAcceptSockAddrs),
		&BytesReturned,
		NULL, NULL))
	{
		cout << "WSAIoctl get GetAcceptexSockAddrs function error,error code " << WSAGetLastError() << endl;
		return false;
	}

	return true;
}
//利用AcceptEx监听accept请求
bool   CServer::PostAccept(COverlappedIOInfo* ol)
{
	if (m_lpfnAcceptEx == NULL)
	{
		cout << "m_lpfnAcceptEx is NULL" << endl;
		return false;
	}
	SOCKET s = ol->m_sSocket;
	ol->ResetRecvBuffer();
	ol->ResetOverlapped();
	ol->ResetSendBuffer();
	ol->m_sSocket = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
	if (ol->m_sSocket == INVALID_SOCKET)
	{
		cout << "WSASocket error ,error code " << WSAGetLastError() << endl;
		return false;
	}
	//这里建立的socket用来和对端建立连接，终会加入m_vecContInfo列表
	//调用acceptex将accept socket绑定至完成端口，并开始进行事件监听
	//这里需要传递Overlapped，new一个COverlappedIOInfo
	//AcceptEx是m_listen的监听事件，m_listen已经绑定了完成端口；虽然ol->m_sSock已经创建，
	//但未使用，现在不必为ol->m_sSock绑定完成端口。在AcceptEx事件发生后，再为ol->m_sSock绑定IOCP
	DWORD byteReceived = 0;
	if (FALSE == m_lpfnAcceptEx(
		m_sListen,
		ol->m_sSocket,
		ol->m_recvBuf.buf,
		ol->m_recvBuf.len - (sizeof(SOCKADDR_IN) + 16) * 2,
		sizeof(SOCKADDR_IN) + 16,
		sizeof(SOCKADDR_IN) + 16,
		&byteReceived,
		ol))
	{
		DWORD res = WSAGetLastError();
		if (ERROR_IO_PENDING != res)
		{
			cout << "AcceptEx error , error code " << res << endl;
			return false;
		}
	}
	std::vector<SOCKET>::iterator iter = m_vecAcps.begin();
	for (; iter != m_vecAcps.end(); iter++)
	{
		if (*iter == s)
		{
			*iter = ol->m_sSocket;
		}
	}
	if (iter == m_vecAcps.end())
	{
		m_vecAcps.push_back(ol->m_sSocket);
	}
	return true;
}
//处理accept请求,NumberOfBytes=0表示没有收到第一帧数据，>0表示收到第一帧数据
bool   CServer::DoAccept(COverlappedIOInfo* ol, DWORD NumberOfBytes )
{
	//分支用于获取远端地址。
	//如果接收TYPE_ACP同时收到第一帧数据，则第一帧数据内包含远端地址。
	//如果没有收到第一帧数据，则通过getpeername获取远端地址
	SOCKADDR_IN* ClientAddr = NULL;
	int remoteLen = sizeof(SOCKADDR_IN);
	if (NumberOfBytes > 0)
	{
		//接受的数据分成3部分，第1部分是客户端发来的数据，第2部分是本地地址，第3部分是远端地址。
		if (m_lpfnGetAcceptSockAddrs)
		{
			SOCKADDR_IN* LocalAddr = NULL;
			int localLen = sizeof(SOCKADDR_IN);
			m_lpfnGetAcceptSockAddrs(
				ol->m_recvBuf.buf,
				ol->m_recvBuf.len - (sizeof(SOCKADDR_IN) + 16) * 2,
				sizeof(SOCKADDR_IN) + 16,
				sizeof(SOCKADDR_IN) + 16,
				(LPSOCKADDR*)&LocalAddr,
				&localLen,
				(LPSOCKADDR*)&ClientAddr,
				&remoteLen);
			cout << "收到新的连接请求,ip=" << inet_ntoa(ClientAddr->sin_addr) << ",port=" << ClientAddr->sin_port <<
				"数据为：" << ol->m_recvBuf.buf << endl;
		}
	}
	else if (NumberOfBytes == 0)
	{
		//未收到第一帧数据
		if (SOCKET_ERROR == getpeername(ol->m_sSocket, (sockaddr*)ClientAddr, &remoteLen))
		{
			cout << "getpeername error,error code " << WSAGetLastError() << endl;
		}
		else
		{
			cout << "收到新的连接请求,ip=" << inet_ntoa(ClientAddr->sin_addr) << ",port=" << ClientAddr->sin_port << endl;
		}
	}

	COverlappedIOInfo* pol = new COverlappedIOInfo;
	pol->m_sSocket = ol->m_sSocket;
	pol->m_addr = *ClientAddr;
	//服务端只收取recv，同时监听recv和send可用设计位偏移，用或运算实现
	if (m_iocp.AsscciateScoket(pol->m_sSocket, TYPE_RECV))
	{
		PostRecv(pol);

		m_vecContInfo.push_back(pol);
	}
	else
	{
		delete pol;
		return false;
	}

	return true;

}
//投递recv请求
bool   CServer::PostRecv(COverlappedIOInfo* ol)
{
	DWORD BytesRecvd = 0;
	DWORD dwFlags = 0;
	ol->ResetOverlapped();
	ol->ResetRecvBuffer();
	int recvnum = WSARecv(ol->m_sSocket, &ol->m_recvBuf, 1, &BytesRecvd, &dwFlags, (OVERLAPPED*)ol, NULL);
	if (recvnum != 0)
	{
		int res = WSAGetLastError();
		if (WSA_IO_PENDING != res)
		{
			cout << "WSARecv error,error code " << res << endl;
		}
	}
	return true;

}
//处理recv请求
bool   CServer::DoRecv(COverlappedIOInfo* ol)
{
	cout << "收到客户端数据：ip=" << inet_ntoa(ol->m_addr.sin_addr) << ",port=" << ol->m_addr.sin_port <<
		"；内容=" << ol->m_recvBuf.buf << endl;
	return true;


}
//从已连接socket列表中移除socket及释放空间
bool   CServer::DeleteLink(SOCKET s)
{
	m_lsc.lock();
	std::vector<COverlappedIOInfo*>::iterator iter = m_vecContInfo.begin();
	for (; iter != m_vecContInfo.end(); iter++)
	{
		if (s == (*iter)->m_sSocket)
		{
			COverlappedIOInfo* ol = *iter;
			closesocket(s);
			m_vecContInfo.erase(iter);
			delete ol;
			break;
		}
	}
	m_lsc.unlock();
	return true;
}
//释放3个部分步骤：
//1：清空IOCP线程队列，退出线程
//2: 清空等待accept的套接字m_vecAcps
//3: 清空已连接的套接字m_vecContInfo并清空缓存
void  CServer::CloseServer()
{
	//1：清空IOCP线程队列，退出线程,有多少个线程发送多少个PostQueuedCompletionStatus信息
	int threadnum = GetThreadsNum();
	for (int i = 0; i < threadnum; i++)
	{
		if (FALSE == m_iocp.PostStatus(TYPE_CLOSE))
		{
			cout << "PostQueuedCompletionStatus error,error code " << WSAGetLastError() << endl;
		}
	}
	//2:清空等待accept的套接字m_vecAcps
	std::vector<SOCKET>::iterator iter = m_vecAcps.begin();
	for (; iter != m_vecAcps.end(); iter++)
	{
		SOCKET s = *iter;
		closesocket(s);
	}
	m_vecAcps.clear();
	//3:清空已连接的套接字m_vecContInfo并清空缓存
	std::vector<COverlappedIOInfo*>::iterator iter2 = m_vecContInfo.begin();
	for (; iter2 != m_vecContInfo.end(); iter2++)
	{
		COverlappedIOInfo* ol = *iter2;
		closesocket(ol->m_sSocket);
		iter2 = m_vecContInfo.erase(iter2);
		delete ol;
	}
	m_vecContInfo.clear();
}
IOCP高性能服务器的实现
m0_50987960的博客
09-08 755
通过完成端口模型构建一款服务器软件，能够接受多个客户端的同时访问，并且每个客户端都可以给服务器发送数据，服务器能接收到客户发来的数据并且统计并打印字节数，并且把打印的字节数发送给客户端。
Nginx事件驱动架构
最新发布
u013257321的博客
02-07 709
事件驱动架构（Event-driven Architecture，EDA）是一种通过事件来驱动系统行为的架构模式，广泛应用于高并发、高性能的应用场景。与传统的线程模型不同，事件驱动架构通过监听、捕获和响应事件来实现系统操作。在Nginx中，事件驱动架构使其能够高效地处理大量并发连接，避免了传统多线程模型中大量线程的创建与销毁所带来的性能开销。
IOCP简单实现
weixin_30410999的博客
08-17 188
本人工作是服务端性能测试，因工作需要开发机器人框架，选用底层的时候看到网上满大街的IOCP介绍，还有说IOCP比WSAAsyncSelect复杂等等，所以只好转WSAAsyncSelect实现。 因并发客户端需要进行调试测试，压力测试工具作为客户端来说性能十分重要，没有经过测试的鬼知道秒并发多少请求，秒并发多少connect，所以就需要实现高效服务端进行调试客户端，在工作之余又继续研究IO...
iocp之简单实现
Hi, Boy
08-03 1055
一、步骤 二、代码 1、头文件 #include &amp;amp;amp;lt;WinSock2.h&amp;amp;amp;gt; #include &amp;amp;amp;lt;Windows.h&amp;amp;amp;gt; #ifdef _WINDOWS #pragma comment(lib,&amp;amp;quot;Ws2_32.lib&amp;amp;quot;) //Socket编程需用的
用完成端口（IOCP）实现一个简单的服务器框架
iunknown
05-25 301
IOCP 对于高并发的应用程序提供了良好的支持，使得开发高并发的应用程序的难度降低了很多。 IOCP 作为系统底层的 API ，保持了尽可能高的灵活性，对于很多复杂的情况，IOCP 也一样适用。 这种灵活性是一种双刃剑，对于复杂的情况，没有这种灵活性就没有办法完成工作。 但是对于简单的情况，这种灵活性就带来了额外的负担。 这里将要提到的这个服务器框架（spserver/iocp版），...
html5 iocp websocket,基于IOCP的简单HTTP，与通用服务开发框架
weixin_30239869的博客
06-15 307
【实例简介】基于IOCP的Socket封装(两个类，一个实现了点HTTP协议，一个原始的数据，方便扩展)【实例截图】【核心代码】基于IOCP的Socket封装(两个类，一个实现了点HTTP协议，一个原始的数据，方便扩展)├── AppManage.html├── AppManageSvr.bdsproj├── AppManageSvr.bdsproj.local├── AppManageSvr.c...
iocp 简单服务器实现
09-12
对初学iocp 很有帮助，简单易懂
用完成端口（IOCP）实现一个简单的socket服务器框架.zip
01-23
本项目"用完成端口（IOCP）实现一个简单的socket服务器框架"旨在提供一个基础的示例，帮助开发者理解如何利用IOCP构建高性能的服务器。 IOCP的基本概念是将I/O操作与线程池解耦，当I/O操作完成时，系统会将结果放入...
C#下IOCP简单例子.rar
03-27
标题"C#下IOCP简单例子.rar"表明这是一个关于使用C#编程语言实现IO完成端口（IOCP，Input/Output Completion Port）技术的示例项目。IOCP是Windows操作系统中用于提高网络I/O性能的一种机制，尤其适用于高并发的...
IOCP方式实现异步套接字源码 v2.0 支持多线程-易语言
06-12
使用内置iocp实现异步操作 使用了线程安全的队列操作回调，保证了对应域下的回调操作不需要加锁 async_socket.e 套接字模块。使用复杂，但是灵活，支持各种协议。 tcpudp.e 傻瓜封装的TCP和UDP模块 简化操作操作流程...
入门级的Windows高性能并发IOCP之DELPHI实现
02-16
为了评估IOCP服务器的性能，我们可以编写一个简单的测试工具，模拟大量并发的SQL查询、文件上传和下载请求，观察服务器的响应时间和资源利用率。这有助于调整服务器配置，优化性能瓶颈，确保系统在高负载下的稳定...
iocp 一个实现不错的类
03-29
这个类还可以的，只是一个基础。要想学习还是可以研究明白
完成端口IOCP实现高并发服务器——一篇非常好的学习资源
10-31
IOCP 实现高并发服务器demo+详解 转载自https://www.cnblogs.com/talenth/p/7068392.html
基于IOCP的简单HTTP，与通用服务开发框架
02-04
基于IOCP的Socket封装(两个类，一个实现了点HTTP协议，一个原始的数据，方便扩展)
一个完成端口模型的实现（IOCP）
07-26
开发环境: VS2010 开发语言: C++ Winsock I/O模型: IOCP (完成端口模型) 代码示例包括Client和Server, common下包括Functor和Thread两个模块。Functor封装了函数对象，用于各种Callback；Thread封装了线程函数对象，用于将类的成员函数绑定到一个线程来执行。 server路径下IServer定义了服务端的接口，CompletionPort实现了IServer，并利用观察者模式和上层解耦。Server的实现分解为IoData, SocketContext, Disposer, Initializer, Parser, Poster, Creator几个主要的模块，并通过CompletionPort包装为统一的接口。其中对于连接的监听采用了AcceptEx函数来实现异步的Accept，该过程定义在WatchProc所对应的线程函数中。IOCPTest定义了服务端的测试接口，可以通过控制命令来实现对Server的Start, Stop, Suspend, Resume操作。 client下IClient定义了客户端的接口，SocketClient实现了IClient，通过ConnectProc以及SendPacketProc两个过程分别控制连接的建立和数据包的发送，并通过队列来管理连接到Server的socket。ClientTest定义了Client端的测试接口，可以自行定义配置信息。 Server运行的过程中会记录日志文件，方便查看服务器的运行状态。
IOCP原理windows下实现
12-29
此包为windows下高并发高性能网络库实现原理阐述，可以做为有封装需求的参考
简单的实现IOCP服务器模型
weixin_33901926的博客
08-17 124
其实已经有很多大佬将原理讲的十分详细了，所以就不花费时间将原理再一次重复讲一遍，有需要的可以自行去查看。 http://blog.youkuaiyun.com/beyond_cn/article/details/9336043这篇文章是我看的，原理介绍十分详细。不过有一些操作感觉比较复杂因此我简化了许多。还是要感谢大佬们倾力普及知识 IOCP模型的关键呢就是将完成端口与套接字绑定起来，然后在这个套接字上...
IOCP实现步骤
zuiyuezhou888的专栏
07-05 2050
IOCP 实现步骤       如果懂得了 IOCP 的工作原理，它实现起来是很简单的。 它的实现步骤如下： 1．   创建好 IOCP 2．   创建 Socket （ socket 可以是由 Accept 得到） 3．   将 Socket 关联到 IOCP 4．   socket 向 IOCP 提交各种所需请求 5．   IOCP 操作完成之后将结果返回给 soc
IOCP 实现的基本步骤
波波诸葛伟
09-25 1517
回顾一下IOCP 是性能最好的一种I/O模型，它是应用程序用线程池处理异步I/O请求的一种机制。在处理多个并发的异步I/O请求时，以往的模型都是在接收请求是创建一个线程来应答请求。这样就有很多的线程并行地运行在系统中。而这些线程都是可运行的，Windows内核花费大量的时间在进行线程的上下文切换，并没有多少时间花在线程运行上。再加上创建线程的开销比较大，所以造成了效率的底下。 调用iocp的步骤如...
UDP客户端IOCP功能实现指南
描述 "实现UDP客户端IOCP功能" 指出文档内容聚焦于UDP通信中的客户端如何利用IOCP（I/O Completion Ports，I/O完成端口）技术。IOCP是Windows平台下一种高效的异步I/O处理机制，它允许应用程序在处理输入输出操作时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值