Iocp

最新推荐文章于 2024-10-08 09:44:01 发布

wu_jing_sheng0

最新推荐文章于 2024-10-08 09:44:01 发布

阅读量416

点赞数

分类专栏： Socket 程序设计文章标签： list socket io null session winapi

Socket 程序设计专栏收录该内容

6 篇文章 0 订阅

订阅专栏

2009-06-04 15:44

//memorypool.h
#pragma once
#include <iostream>
#include <list>
#include <windows.h>

//关键区锁
class CLock
{
     CRITICAL_SECTION _crisection;
public:
     CLock()
     {
         InitializeCriticalSection( &_crisection );
     }
     ~CLock()
     {
         DeleteCriticalSection( &_crisection );
     }
     void lock()
     {
         EnterCriticalSection( &_crisection );
     }
     void unlock()
     {
         LeaveCriticalSection( &_crisection );
     }
};
//内存池模型：实质就是一个前向指针链表
template <class particle>
class particle_allocator
{
     enum
     {
         chunk_size =1024
     };
     typedef unsigned char byte;
     struct particle_list
     {
         particle *_data;
         particle_list *_next;
     };
     std::list<particle *> _chunks;
     particle_list* _free_list;

     CLock _guard;
public:
     particle_allocator()
     {
         _free_list = 0;
         _used_particle_number = 0;
         _free_particle_number = 0;
     }
     ~particle_allocator()
     {
         for(std::list<particle *>::iterator iter = _chunks.begin();iter!=_chunks.end();++iter)
         {
             delete (*iter);
         }
         _chunks.clear();
         while(_free_list)
         {
             particle_list *temp = _free_list;
             _free_list = _free_list->_next;
             delete temp;
         }
     }
     particle* alloc_particle()
     {
         _guard.lock();
         byte *momory;
         particle_list* &current_list = _free_list;
         if(!current_list)
         {
             momory = new byte[chunk_size*sizeof(particle)];
             for(int i = 0;i<chunk_size;i++)
             {
                 _chunks.push_front((particle *)(momory + i*chunk_size));
             }
             for(int i =0;i< chunk_size;i++,_free_particle_number++)
             {
                 particle_list *newnode = new particle_list;
                 newnode->_data = (particle *)(momory + i*sizeof(particle));
                 newnode->_next = current_list;
                 current_list = newnode;
             }
         }
         particle   *redata;
         particle_list *de_node = current_list;
         redata = _free_list->_data;
         current_list = current_list->_next;
         ++_used_particle_number;
         --_free_particle_number;
         delete de_node;
         _guard.unlock();
         return new(redata) particle;
     }
     void free_particle(particle   *p)
     {
         particle *free_block = p;
         _guard.lock();
         particle_list* &current_list = _free_list;
         particle_list *newnode = new particle_list;
         newnode->_data = free_block;
         newnode->_next = current_list;
         current_list = newnode;
         --_used_particle_number;
         ++_free_particle_number;
         _guard.unlock();
     }
     void getallocator()
     {
         using namespace std;
         cout << "_used_particle_number is " << _used_particle_number << " _free_particle_number is "<< _free_particle_number << endl;
     }
public:
     size_t _used_particle_number;
     size_t _free_particle_number;
};
//这个是内存分配优化类，由于服务器需要运行在一个相对静态的环境中。所以我第每次分配1024块某种结构的内存。用完继续分配1024块，使用的时候就在分配好的内存里边取一块，用完再归还回去。
//iocpsever.cpp
#include <winsock2.h>
#include "memorypool.h"
#include <Mswsock.h>

using namespace std;

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

// 单句柄数据，每个连接（客户端）对应一个这样的结构。
//只有连接断开，或者服务器关闭的时候才释放
typedef struct tagPER_HANDLE_DATA
{
     SOCKET Socket;
     SOCKADDR_STORAGE ClientAddr;
     // 将和这个句柄关联的其他有用信息，尽管放在这里面吧
}PER_HANDLE_DATA, *LPPER_HANDLE_DATA;

// 单I/O操作数据。每次收发数据的时候
//收发数据操作完成数之后释放。
//需要注意的是OVERLAPPED Overlapped一定要放在最前
typedef struct tagPER_IO_DATA
{
     OVERLAPPED Overlapped;
     WSABUF DataBuf;
     char buffer[1024];
     DWORD BufferLen;
     int OperationType;
     SOCKET Socket;
     LPPER_HANDLE_DATA lpSession;
}PER_IO_DATA, *LPPER_IO_DATA;
//操作标志
#define OP_READ     0
#define OP_WRITE     1
#define OP_ACCEPT   2
//连接数据内存池
particle_allocator<PER_IO_DATA> g_per_io_data;
//数据收发内存池
particle_allocator<PER_HANDLE_DATA> g_per_handle_data;
//完成线程
DWORD count = 0;
//保存当前连接数据指针
list<LPPER_HANDLE_DATA> g_session;
//接受事件
HANDLE g_hAcceptExOverEvent = NULL;
//工作线程
DWORD WINAPI ServerWorkerThread(LPVOID lpParam);

using namespace std;

int main(void)
{
     WSADATA wsd;
     SYSTEM_INFO SystemInfo;
     SOCKADDR_IN InternetAddr;
     SOCKET Listen;
     WSAStartup(MAKEWORD(2, 2), &wsd);

     //创建完成端口
     HANDLE CompletionPort = CreateIoCompletionPort(INVALID_HANDLE_value,
         NULL,
         0,
         0);

     //得到处理器数量
     GetSystemInfo(&SystemInfo);
     //经验公式：一般按公式创建工作线程
     count = 2*(SystemInfo.dwNumberOfProcessors+1);

     for (DWORD i = 0; i < count; ++i)
     {
         HANDLE ThreadHandle;

         ThreadHandle = CreateThread(NULL,
             0,
             ServerWorkerThread,
             CompletionPort,
             0,
             NULL);

CloseHandle(ThreadHandle);
}

//创建监听socket

     Listen = WSASocket(AF_INET,
         SOCK_STREAM,
         0,
         NULL,
         0,
         WSA_FLAG_OVERLAPPED);

     InternetAddr.sin_family = PF_INET;
     InternetAddr.sin_port = htons(10000);
     InternetAddr.sin_addr.s_addr = htonl(INADDR_ANY);
     //帮定到指定端口

bind(Listen, (SOCKADDR*)&InternetAddr, sizeof(InternetAddr));

     //开始监听
     listen(Listen, SOMAXCONN);
     //完成端口帮定到监听socket
     if (CreateIoCompletionPort((HANDLE) Listen, CompletionPort, (ULONG_PTR)&Listen, count) == NULL)
     {
         printf("CreateIoCompletionPort failed with error %d/n", GetLastError());
         return 1;
     }
     //创建事件
     g_hAcceptExOverEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
     if(!g_hAcceptExOverEvent)
     {
         return 1;
     }
     //帮定事件，由于我们用AcceptEx是一个异步的投递，这样帮定之后，如果投递的AcceptEx事件全部完成
     //则g_hAcceptExOverEvent事件得到通知，进而同步AcceptEx调用
     if(WSAEventSelect(Listen, g_hAcceptExOverEvent, FD_ACCEPT) == SOCKET_ERROR)
     {
         return 1;
     }
     //由于开始是复位，变成置位
     SetEvent(g_hAcceptExOverEvent);
     BOOL b = TRUE;

     while (b)
     {
         //每次投递10次，进入等待状态，当AcceptEx全部完成之后，继续投递
         if(WaitForSingleObject(g_hAcceptExOverEvent, INFINITE) == WAIT_FAILED)
             continue;
         for(int i =0;i<10;i++)
         {
             int zero =0;
             PER_IO_DATA * pper_io_data = NULL;
             DWORD dwAddrLen   = sizeof(sockaddr_in)+16;
             pper_io_data = (PER_IO_DATA *)g_per_io_data.alloc_particle();
             pper_io_data ->Socket = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
             pper_io_data->OperationType = OP_ACCEPT;
             pper_io_data->lpSession=NULL;
             ZeroMemory(&pper_io_data->Overlapped,sizeof(OVERLAPPED));//一定要注意清零
             //这里pper_io_data->Overlapped，将来会在工作线程里返回，工作线程里有这样的代码
             //bRet = GetQueuedCompletionStatus(CompletionPort,
             //     &BytesTransferred,
             //     (PULONG_PTR)
             //     &lpCompletionKey,
             //     (LPOVERLAPPED*)
             //     &pOldPerIoData,
             //     INFINITE);
             //我们这里为什么可以这么用pOldPerIoData，是因为它是一个PER_IO_DATA指针，但是PER_IO_DATA结构的第一成员是
             //Overlapped，所以pper_io_data->Overlapped与pOldPerIoData地址是相同的。
             if(!AcceptEx(Listen,pper_io_data ->Socket,pper_io_data ->buffer,0,dwAddrLen,dwAddrLen,&pper_io_data ->BufferLen,&pper_io_data->Overlapped))
             {
                 if(WSAGetLastError() != ERROR_IO_PENDING)//对于AcceptEx，WSARecv,WSASend一定要有这样的判断，因为是异步的所以不会立即完成
                 {
                     closesocket(pper_io_data->Socket);
                     g_per_io_data.free_particle(pper_io_data);     //归还结构体到内存池
                     continue;
                 }

             }
         }
     }
     CloseHandle(g_hAcceptExOverEvent);
     return 0;
}
DWORD WINAPI ServerWorkerThread(LPVOID lpParam)
{
     HANDLE CompletionPort = (HANDLE)lpParam;
     DWORD BytesTransferred;
     LPPER_IO_DATA pOldPerIoData = NULL;
     LPPER_IO_DATA pNewPerIoData = NULL;
     LPPER_HANDLE_DATA lpSession =NULL;
     LPVOID lpCompletionKey = NULL;
     DWORD RecvBytes;
     DWORD Flags;
     BOOL bRet = FALSE;

     while (1)
     {
         bRet = GetQueuedCompletionStatus(CompletionPort,
             &BytesTransferred,
             (PULONG_PTR)
             &lpCompletionKey,
             (LPOVERLAPPED*)
             &pOldPerIoData,
             INFINITE);
         if(!bRet && !pOldPerIoData)//没有从完成队列中取到任何东西。
         {
             continue;
         }
         if(bRet == ERROR_SUCCESS &&
             BytesTransferred == 0 &&
             pOldPerIoData)//断开连接
         {
             closesocket(pOldPerIoData->Socket);             //关闭socket
             g_session.remove(lpSession);                 //从Session链表中删除
             g_per_handle_data.free_particle(lpSession);     //将Session归还到池
             g_per_io_data.free_particle(pOldPerIoData);

         }
         switch (pOldPerIoData->OperationType)
         {
         case OP_ACCEPT://有连接进来
             {
                 if(!bRet)//连接失败
                 {
                     closesocket(pOldPerIoData->Socket);
                     g_per_io_data.free_particle(pOldPerIoData);
                     break;
                 }
                 //用每个连接（客户端）相关的数据（g_per_handle_data）帮定完成键
                 lpSession=g_per_handle_data.alloc_particle();
                 lpSession->Socket = pOldPerIoData->Socket;//就是我们AcceptEx时传入的socket
                 g_session.push_front(lpSession);
                 if(!CreateIoCompletionPort(
                     (HANDLE)pOldPerIoData->Socket,
                     CompletionPort,
                     (ULONG_PTR)lpSession,
                     count))
                 {
                     closesocket(pOldPerIoData->Socket);             //关闭socket
                     g_session.remove(lpSession);                 //从Session链表中删除
                     g_per_handle_data.free_particle(lpSession);     //将Session归还到池
                 }
                 else
                 {
                     //向完成队列投递异步读操作
                     //分配操作缓存，g_per_io_data与每次读写相关联
                     pNewPerIoData = (LPPER_IO_DATA)g_per_io_data.alloc_particle();
                     pNewPerIoData->Socket = pOldPerIoData->Socket;
                     pNewPerIoData->OperationType = OP_READ;
                     ZeroMemory(&(pNewPerIoData->Overlapped), sizeof(OVERLAPPED));
                     Flags = 0;
                     pNewPerIoData->DataBuf.len = 1024;
                     pNewPerIoData->DataBuf.buf = pNewPerIoData->buffer;
                     pNewPerIoData->lpSession = g_per_handle_data.alloc_particle();
                     if(WSARecv(pNewPerIoData->Socket,
                         &(pNewPerIoData->DataBuf),
                         1,
                         &RecvBytes,
                         &Flags,
                         &(pNewPerIoData->Overlapped),
                         NULL)== SOCKET_ERROR)
                     {
                         if(WSAGetLastError() != ERROR_IO_PENDING)//读操作失败
                         {
                             closesocket(pOldPerIoData->Socket);             //关闭socket
                             g_session.remove(pNewPerIoData->lpSession);     //从Session链表中删除
                             g_per_handle_data.free_particle(pNewPerIoData->lpSession);     //将Session归还到池
                             g_per_io_data.free_particle(pNewPerIoData);//归还OV结构体到内存池
                         }
                     }
                 }
                 g_per_io_data.free_particle(pOldPerIoData);

}

             break;
         case OP_READ:
             pNewPerIoData = (LPPER_IO_DATA)g_per_io_data.alloc_particle();
             if (pNewPerIoData)
             {
                 pNewPerIoData->Socket = pOldPerIoData->Socket;
                 pNewPerIoData->OperationType = OP_READ;
                 ZeroMemory(&(pNewPerIoData->Overlapped), sizeof(OVERLAPPED));
                 Flags = 0;
                 pNewPerIoData->DataBuf.len = 1024;
                 pNewPerIoData->DataBuf.buf = pNewPerIoData->buffer;
                 pNewPerIoData->OperationType = 0; // read
                 pNewPerIoData->lpSession =   pOldPerIoData->lpSession;
                 if(WSARecv(pNewPerIoData->Socket,
                     &(pNewPerIoData->DataBuf),
                     1,
                     &RecvBytes,
                     &Flags,
                     &(pNewPerIoData->Overlapped),
                     NULL)== SOCKET_ERROR)
                 {
                     if(WSAGetLastError() != ERROR_IO_PENDING)
                     {
                         closesocket(pOldPerIoData->Socket);             //关闭socket
                         g_session.remove(pNewPerIoData->lpSession);     //从Session链表中删除
                         g_per_handle_data.free_particle(pNewPerIoData->lpSession);     //将Session归还到池
                         g_per_io_data.free_particle(pNewPerIoData);//归还OV结构体到内存池
                     }
                 }
                 cout << pOldPerIoData->DataBuf.buf << endl;
                 send(pOldPerIoData->Socket,"9876543210",lstrlen("9876543210")+1,0);
                 g_per_io_data.free_particle(pOldPerIoData);
             }

             break;
         case OP_WRITE: