可伸缩的IO完成端口服务器模型(IOCP)(中文版)

来源：互联网发布：win7无法保存网络凭证编辑：程序博客网时间：2024/04/28 19:28

http://blog.csdn.net/chcucl/article/details/8058878

来源：CodeProject

翻译：Kevin Chen

Email:chcucl@sina.com

URL:http://www.codeproject.com/KB/IP/IOCP_how_to_cook.aspx

http://www.codeproject.com/Articles/20570/Scalable-Servers-with-IO-Completion-Ports-and-How

备注：此文是本人首次翻译，如果不精确或者难以理解的地方，请查阅原文章。

1、简介：

该文主要介绍三个主题：线程管理，内存管理，和客户端套接字处理结构。这里使用TCP套接字。

2、线程

通常，当开发服务器程序时，线程模型的使用可以被分为以下两种：

l 容易实现的，一个（服务）线程对应一个客户端连接/套接字

l 复杂一点的，使用线程池（如：固定大小线程池，基于超时的线程池，可变大小的线程池，等等）。

而第一个模型通常是最容易实现的一个，但是当服务于大量连接的时候不是一个最好的选择，有两点原因：

l 上下文切换，它是OS对相同或者不同进程的两个正在运行的进程或线程进行切换的处理，包括保存和载入运行线程/进程的上下文，在这种方式下好像每个个线程继续执行，但事实上，它们也许共享一个CPU。显然，上下文切换需要时间，并且这个时间基于操作系统的实现。在Windows操作系统中，切换大概需要十亿分之一秒。而在一些旧版本/分布式LINUX系统中，切换大概需要2毫秒，所以，假如创建了1000个线程，并且所有线程有相同的优先级，则有2毫秒乘以1000，约2秒耗费在上下文切换上，这是不可接受的。显然，需要一种不同的模型

l 通常，线程在“一个线程对应一个连接”的模型中，线程大部分时间什么也不做。比如：当执行套接字的阻塞I/O操作时线程会被挂起。创建大量的线程不过是浪费资源。

文章中所描述的IOCP框架所使用的线程模型是CSimpleThreadPool类。这个线程框架并没有什么特别的，我会提供一些我使用这种模型的原因：

l 它非常轻巧，非常有用而且容易使用。

l CSimpleThreadPool是一个固定大小的线程池。预先创建一定数量的线程将有助于减少运行时用于创建线程的时间，因为它们已经被创建。因为创建线程是需要时间的（操作系统必须创建一个系统对象，创建一个线程栈，等等）。所以这将获得更好的性能。

l 主要原因是，CSimpleThreadPool是一个包含一个优先级队列的线程池。下面详细描述其细节，IOCP队列不会对完成请求按优先级进行排序。所有的完成请求拥有相同的优先级。所以，可以写一个简单的程序，建立数千个连接，然后一下子全关闭它们，重复创建和关闭...。IOCP将在队列中记录大量的关闭请求，事实上，服务端会仅忙于处理关闭请求。这是一个拒绝服务攻击列子。IOCP没有使用优先级队列对完成请求进行排序是很糟糕的，但是，我猜想也许有什么技术原因导致没有使用优先级队列。然而，来自IOCP的完成请求会被传递到CSimpleThreadPool的队列，并且它们会被按照优先级排序。因此，关闭连接请求会有比其他完成请求更低的优先级。这是一种相对于前文所描述的攻击的保护策略

3、内存管理

和开发服务器程序相关的另一个问题是正确的内存管理，尽管非常熟悉的操作如new和delete（类似的，malloc和free，或者其它的低等级的WinSDK API）用起来非常繁琐，但问题是，当谈到这个程序运行一天24小时，每周7天，每年365天。

问题被称为内存碎片。这些操作（API）被设计为可以分配连续的内存块，但是如果程序频繁的执行new/delete，并且内存块大小不一，程序将以new返回NULL而结束（也许会时常发生），尽管程序在堆上有足够的空间。这种情况也许会经常发生，因为没有满足请求大小的连续的空余内存空间，换句话说，我们有内存碎片，或早或晚，服务器将失败。

有几种方案应对内存碎片问题：

l 实现垃圾回收，执行碎片整理。

l 自定义内存管理旨在防止潜在的内存碎片，对new/delete的重载，仅仅是为了是最终解决方案优雅而已。

l 使用new（malloc）操作分配一个指定大小的内存块，不过，内存仍然会有碎片，但是碎片是固定大小（或者是一个系数乘以固定大小）。这是一种非常容易实现的机制。然而，如果实际内存是从1KB到1MB，分配1MB的内存块，即使只需要1KB。这只不过是浪费内存。

l 预分配一块内存区域，在这种情况下，当可以估算服务一个连接所需要的内存大小，用单个连接所需内存大小值乘以允许的最大连接数（配置参数）。通过所获取的值，分配一块指定大小的连续内存并且在这块内存区域中执行操作。这是另一种非常容易使用机制，并且工作良好，前提是能够估算内存大小。

l 重用所使用的内存块。这种构思非常简单，一旦分配了一个内存块，当它不用时不要删除它，仅仅标记为未使用并且在下一次重用它。这也许看起来像内存泄露，但事实上，这仅仅是处理内存碎片的一种策略。

下面一个模板类，运用了以上所描述的“预分配内存区域”和“重用内存块”机制。

// A template class allowing re-using of the memory blocks.

template<class T>

class QueuedBlocks {

private:

QMutex m_qMutex;

set< T* > m_quBlocks;

vector< T* > m_allBlocks;

public:

QueuedBlocks(int nInitSize = 1):

m_qMutex(), m_quBlocks(), m_allBlocks() {...};

// get a free block from the queue, if one cannot be found

// then NULL is returned

T* GetFromQueue() {...};

// get a free block from the queue, if one cannot be found

// then a new one is created

T* Get() {...};

// Release the used block, place it

// back to the queue. For performance reason,

// we assume that the block was previously taken

// from the queue.

void Release(T* t) {...};

// Return all the blocks ever allocated.

vector<T*> *GetBlocks() {...};

~QueuedBlocks() {...};

};

这样，通过构造函数，我们预分配了一些需要的对象，并且：

l 如果仅仅需要“预分配内存区域”机制，仅仅使用GetFromQueue()和Release()函数，这样它将会“在已分配内存区域中”工作

l 如果需要“重用内存块”机制（同“预分配内存区域机制一起使用”），使用Get()和Release()函数，如果预分配的空间不够用，它将扩展预分配内存区域。

因为这是一个通用模板，它允许自定义一个不同类/结构的队列。这种实现的问题是，每个特定的类必须有一个默认的构造函数和一个 Clear() 函数。 Clear() 函数目的是在内存块将要被重用前执行内部清理，

另一个有用的模板类是：

// A template class used for providing free blocks as well

// as releasing unnecessary ones. Uses "QueuedBlocks" which

// allows reusing of the blocks.

template<class T>

class StaticBlocks {

private:

static QueuedBlocks<T> *blocks;

public:

static void Init(int nSize = 1) {...};

static T *Get() {...};

static void Release(T *b) {...};

};

它代表QueuedBlocks的一个适配器，但是所有函数都被定义为static，当需要在不同类中共享内存块时这将非常有用。

4、关于IOCP的几个事实

如果你正在读这篇文章，你也许知道使用IOCP的优势。如果你不知道，那么...，IOCP是开发可伸缩的服务器程序最好的模型，它能仅使用少量线程处理数千个连接。这是如何实现的？通过使用一种称为“I/O完成端口”的系统对象，该系统对象使一个程序接收异步I/O的完成通知。所以，任何I/O操作都是异步（立即完成），程序（或线程）在I/O操作完成时收到通知，因此，程序（或者程序中的线程）有足够的时间去处理任何其它的操作（而不是等待I/O操作，这通常发生在“一个线程服务一个连接/套接字”模型上）。让我们概述下我们所知道的关于IOCP的事实。

首先，为了使套接字受益于IOCP，必须使用WinSock API的重叠I/O版本。

WSASend(...);

WSARecv(...);

第二点，一个套接字必须被设置为支持重叠API。

nSock = WSASocket(..., ..., ..., ..., ..., WSA_FLAG_OVERLAPPED);

同时，我们也需要创建一个IOCP句柄。

hIocp = CreateIoCompletionPort( INVALID_HANDLE_VALUE, NULL, 0, 0 );

然后，我们需要将这个套接字关联到IOCP上。

CreateIoCompletionPort( (HANDLE) nSock, hIocp, ..., ... );

现在，当在套接字上使用重叠I/O操作时，I/O操作必须被注册到IOCP的队列里。这个注册项仅仅在执行I/O操作时发生，否则，这个注册项不会被执行。尽管这个套接字已经和IOCP关联。当一个重叠I/O操作的完成时，将通过下面的调用从IOCP队列中返回（事实上，仅仅是一些操作的详细信息，但是，它有些技巧，后面将详细介绍）：

GetQueuedCompletionStatus( hIocp, &dwBytesTransferred, ..., lpOverlapped, dwTimeout );

至此，我们知道一个套接字的I/O操作已经成功完成。根据这些事实，让我们开始一些支持这些机制的类的实现。

5、Client/Server 套接字

首先，让我们分析ClientSocket 这个模板类（完整的源代码，请查看附件资源）

// A class wrapping basic client socket's operations

template<class T>

class ClientSocket {

private:

SOCKET m_ClientSock;

volatile unsigned int m_nSession;

QMutex m_qMutex;

struct sockaddr_in m_psForeignAddIn;

volatile bool m_blnIsBusy;

T m_objAttachment;

protected:

public:

ClientSocket(): m_objAttachment(), m_qMutex() {...}

~ClientSocket() {...}

// Is the object assigned a socket.

bool IsBusy() {...};

// Method is used by 'QueuedBlocks' from

// "mem_manager.h".

void Clear() {...}

// Returns the socket associated with the object.

SOCKET GetSocket() {...}

// Returns the session of the current client socket.

// Technically, this is the counter of how may times

// current instance was pooled, but really, this is used

// to check if session of operation (MYOVERLAPPED)

// is == with the session of the socket.

unsigned int GetSession() {...}

// Internally used by this implementation. Don't call it.

void Lock() {...}

// Internally used by this implementation. Don't call it.

void UnLock() {...}

// Associate the object with a socket.

int Associate(SOCKET sSocket, struct sockaddr_in *psForeignAddIn) {...}

// Returns the attachment of the object.

// Use the attachment to associate the socket with any other

// additional information required.

T* GetAttachment() {...}

// Write data to the socket,

// uses overlapped style.

int WriteToSocket(char *pBuffer, DWORD buffSize) {...}

// Read data from the socket,

// uses overlapped style.

int ReadFromSocket(char *pBuffer, DWORD buffSize) {...}

// Closes the socket associated with this instance

// of the object and performs clean-up.

void CloseSocket() {...}

};

下面是一些有关这个类的几个要点：

l 设计这个类仅仅是为了与ServerSocket类一起工作（下面将详细叙述），单独使用时是没什么用的。

l 它封装了重叠I/O的 WinSock API。

l 这是一个通用的模板类可以支持“附件”（查阅GetAttachment()函数）。虽然ClientSocket的基础功能非常的普通，但是，附件允许扩展ClientSocket类的功能（例如：保存套接字的当前状态，包含供读写的数据缓存，等等）。对用作附件的结构体/类的唯一的限制是：必须有一个默认的构造函数和一个Clear()函数（用作执行内部清理）。还有一些其它的要求，将在稍后叙述。

l 这个类的设计可以让ServerSocket重复使用已经创建的实例。如我们稍后所见，ServerSocket包含一个QueuedBlocks<ClientSocket<T> >（ClientSocket必须实现Clear()），这就是为什么套接字句柄不是传给构造函数，而是关联到一个空闲（IsBusy()）的实例（通过Associate()函数）。

其次，让我们分析ServerSocket 这个模板类（完整的源代码，请查看附件资源）

// A class for handling basic server socket operations.

template<class T>

class ServerSocket {

private:

// Server socket.

SOCKET m_ServSock;

// Pool of client sockets.

QueuedBlocks<ClientSocket<T> > m_SockPool;

protected:

public:

// Set the size of the socket pool to the maximum number of accepted

// client connections.

ServerSocket(unsigned int nPort, unsigned int nMaxClients,

bool blnCreateAsync = false,

bool blnBindLocal = true): m_SockPool(nMaxClients) {...}

// Returns a pointer to the ClientSocket instance, bind

// to the accepted client socket (incoming connection).

ClientSocket<T>* Accept() {...}

// Release the client socket, will try closing connection and

// will place it back to the pool.

void Release(ClientSocket<T> *sock) {...}

vector<ClientSocket<T> *> *GetPool() {...}

~ServerSocket() {...}

};

下面是一些有关这个类的几个要点：

l 这是一个模板类，原因仅仅是它操作了模板类ClientSocket（重复，重点在“附件”）。

l 它和固定数量的ClientSocket实例一起工作，这就是为什么Accept()，在内部，调用m_SockPool的GetFromQueue()函数（而不仅仅是Get()函数）。事实上，这模拟了服务器在同一时间可以服务的最大的活动连接数。最大活动连接数是通过nMaxClients这个参数传递给构造函数的。

l Accept()函数返回准备使用的从m_SockPool中获取的一个ClientSocket实例。这个实例被关联到已接收到的连接的套接字。Release()函数用来关闭套接字句柄（如果没有关闭），并且将这个ClientSocket实例返回给m_SockPool队列，为了在后面重复使用。

l GetPool()函数覆盖了m_SockPool的GetBlocks()函数。它简单的返回了在队列中所有的ClientSocket实例（全部的，包括哪些没有被套接字句柄的关联的实例）。这个函数在将队列传递给CTimeOutChecker的时候被ServerService调用。稍后详细叙述。

l 这个函数的构造函数，在内部，执行了创建服务端套接句柄所需要的所有操作，绑定套接字到一个指定端口（通过nPort传递给构造函数）和IP地址，并且将这个套接字设置为监听模式（详细请参考代码）。如果这些操作中有任何一个失败，将抛出一个异常。

6、MYOVERLAPPED结构体

OVERLAPPED 对WinSock API 的重叠I/O操作和IOCP来说是一个非常重要结构体。它被IOCP系统对象使用（不仅仅如此，但是，我将跳过一些不需要的细节），用于“跟踪”I/O操作的状态。但是，OVERLAPPED 本身太没用了。这就是为什么要扩展的原因。有一个小窍门，当然（完整的定义在socket_client.h中）。

// Overlapped structure used with this implementation of the IOCP.

// Only the "Overlapped" member is used in context with the

// standard IOCP API, anything else is just to help this particular

// implementation.

typedef struct {

// It is very important "Overlapped" to be the very first

// member of the structure because pointer pointing to

// "this" is == to the address of the first member.

// This makes usage of the MYOVERLAPPED equivalent

// to the OVERLAPPED in context of the standard IOCP API (just a trick).

OVERLAPPED Overlapped;

// A structure that points to the data packet and size of the data

// packet associated with current overlapped operation.

WSABUF DataBuf;

// Operation type associated with current overlapped operation.

IO_SOCK_MODES OperationType;

// Internally used. If nSession != ClientSocket::m_nSession

// that means that socket was closed (recently) and

// operation retrieved from IOCP queue or TaskPool queue

// is not relevant, to the current session of the socket.

volatile unsigned int nSession;

// Method is used by 'QueuedBlocks' from

// "mem_manager.h".

void Clear() {...}

} MYOVERLAPPED;

窍门在哪里？窍门就是OVERLAPPED 结构体必须是MYOVERLAPPED结构体的第一个成员。这样，MYOVERLAPPED的一个实例的内存地址就等于结构体的第一个成员的地址（在这种情况下是OVERLAPPED ）。因此，传递（ WSASend()/WSARecv() ）或者接收（ GetQueuedCompletionStatus()）一个MYOVERLAPPED的指针（当然，通过正确的转换）是相同的，如果我们使用的是原有的OVERLAPPED 结构。

这仅仅是一个小窍门，有几点益处：

l 关于MYOVERLAPPED，我们总是能通过OperationType类型知道已经成功完成得操作的类型（例如：READ或者WRITE）。因为这样，我冒着风险将一个MYOVERLAPPED实例定义成“操作”（为简单起见）。

l 关于DataBuf成员，我们知道成功完成得操作的数据缓冲区的详细信息（参考ClientSocket的WriteToSocket()和ReadFromSocket() ）。

l nSession成员是这篇文章所描述的IOCP框架的另一个窍门。ClientSocket有一个Session（参考上文第5段），并且MYOVERLAPPED也有一个Session。ClientSocket的实例的Session在每次ServerSocket::Release()被调用时递增（这意味着，这个实例将被重用）。当调用WriteToSocket()或者ReadFromSocket()函数时，在内部，它们将当前ClientSocket的Session设置为用于操作的MYOVERLAPPED实例的Session。当通过GetQueuedCompletionStatus()接收到完成操作时，并且如果返回操作的Session不同于ClientSocket实例所添加的Session，则这个操作时无意义的，因为ClientSocket实例已经成功关闭或者，也许，被重用了，当这个操作获得IOCP队列响应。所以，在代码里，你会看到一些这样的检查。

并且，因为MYOVERLAPPED被不同的类共享，以下描述（如第3段所描述的）是很重要的。

// a pool of the MYOVERLAPPED structures

typedef StaticBlocks<MYOVERLAPPED> Overlapped;

QueuedBlocks<MYOVERLAPPED> *Overlapped::blocks = NULL;

7、IOCPSample 类

IOCPSample是这篇文章所描述的架构中的其中一个核心模板类（关于完整的代码，请参考附件资源中iocp.h文件）。

// A template class (wrapper) to handle basic operations

// related to IO Completion Ports (IOCP).

template<class T>

class IOCPSimple {

private:

HANDLE m_hIocp;

DWORD m_dwTimeout;

protected:

// Useful method to queue a socket (handler in fact) in the IOCP's

// queue, without requesting any 'physical' I/O operations.

BOOL PostQueuedCompletionStatus( ClientSocket<T> *sock,

MYOVERLAPPED *pMov ) {...}

public:

~IOCPSimple() {:}

IOCPSimple( DWORD dwTimeout = 0 ) {...}

// Method associates Socket handler with the handler

// of the IOCP. It is important to do this association

// first of all, once Socket is accepted and is valid.

// In fact, this method registers socket with the IOCP,

// so IOCP will monitor every I/O operation happening

// with the socket.

void AssociateSocket( ClientSocket<T> *sock ) {...}

// Queue in the IOCP's queue with the status 'pending'.

// This is a fictive status (not real). Method is useful in

// cases when packets/data buffers to send via socket are yet

// not ready (e.g. due some internal, time consuming, calculations)

// and rather than keeping socket somewhere, in separate structures,

// place it in the queue with status pending. It will be returned

// shortly with the "GetQueuedCompletionStatus" call anyway.

BOOL SetPendingMode( ClientSocket<T> *sock ) {...}

// Queue in the IOCP's queue with the status 'close'.

// This is a fictive status (not real). Useful only

// when close socket cases should be treated/handled

// within the routine, handling I/O completion statuses,

// and just to not spread the code across different

// modules/classes.

BOOL SetCloseMode( ClientSocket<T> *sock,

MYOVERLAPPED *pMov = NULL ) {...}

// Queue in the IOCP's queue with the status 'accept'.

// This is a fictive status (not real). When a new

// client connection is accepted by the server socket,

// method is used to acknowledge the routine, handling

// I/O completion statuses, of this. Same reason as per

// 'close' status, just to have a unique piece of code

// handling all the possible statuses.

BOOL SetAcceptMode( ClientSocket<T> *sock ) {...}

// This method is just a wrapper. For more details,

// see MSDN for "GetQueuedCompletionStatus". The only

// difference is, method is adjusted to handle

// 'ClientSocket<T>' (as registered with 'AssociateSocket(...)')

// rather than pointer to the 'DWORD'.

BOOL GetQueuedCompletionStatus( LPDWORD pdwBytesTransferred,

ClientSocket<T> **sock, MYOVERLAPPED **lpOverlapped ) {...}

};

因此，这个类仅仅是关于IOCP的API函数的简单封装，并且这是一个通用模板类，因为ClientSocket是一个模板类，关于IOCP逻辑的大部分细节，我们已经在第4节讨论过了，但是，仍然有些额外的东西要写。

下面函数第3个参数：

CreateIoCompletionPort( ..., ..., Key, ... );

预定是一个DWORD，在API中它被命名为Key，这个Key在I/O操作完成被返回到下面函数的第3个参数。

GetQueuedCompletionStatus( ..., ..., &Key, ..., ... );

Key可以是任何可以被转换为DWORD类型的类型（当然，使用类型转换）。例如：Key可是一个指向对象的指针。如果我们使用这个指针，作为一个Key，则ClientSocket实例的指针是相对于被执行的那个I/O操作？是的，这使得我们不仅仅知道了完成的操作，而且，ClientSocket的实例是是被应用的那个I/O操作。这里有另一个窍门，是IOCPSimple 的AssociateSocket() 和GetQueuedCompletionStatus()方法。

8、IOCPSample的SendPendingMode方法

我应该写一点关于IOCPSample模板类的SetPendingMode() 方法。它太有用的同时也太危险。考虑一种情况，当你的程序正在从外部资源成块的读数据，并且将它们发送给ClientSocket的一个实例。如果外部资源没有准备好返回下一块数据（因为任何原因），则没有任何数据被发送到ClientSocket，因此，没有任何I/O操作在IOCP中被查询（如第4节所描述的）。所以，ClientSocket的状态是未定义的，并且非常有可能“失去”这样的一个套接字。使用SetPendingMode()方法，而不是实现一个缓冲存储区去“保持这些套接字并且当有数据时再处理它们”。这个方法将套接字推送到IOCP的队列，并且，一小段时间后，这个套接字将会被ISockEvent的OnPending() 事件返回（更多详细信息见下章）。很有可能的是，在那个时候，外部资源的下一个数据块已经准备好被发送了（如果没有，再次使用OnPending() ）。

这是非常有用的，但是，注意SetPendingMode()仅仅是将套接字推送到IOCP的队列中，没有实际注册任何I/O操作。非常有可能的是，当用这种方式推送套接字到IOCP队列中的时候，这个套接字也许被远端关闭了。不幸的是，IOCP将不会处理这类“意外的”关闭直到和这个套接相关联的一个实际的I/O操作被执行。这种情况将被CTimeOutChecker 很好的“过滤”掉（更详细的信息见下一节，所以，不要轻视它），并且或早或晚（根据传递的超时值），这样的套接字将会被“拒绝”，通过ISockEvent的OnClose() 事件，只要超时值大于0（并且CTimeOutChecker 被使用）。提醒自己注意。

9、CTimeOutChecker类

这个模板类在server_server.h文件中被定义，有一个作用是检查每一个活动连接是否超时，当过去的时间，自从上次的I/O操作，大于传递给构造函数的nTimeOutValue时一个超时情况发生。

// A template class designed for verifying client sockets

// against time-out cases. Time-out case = if no I/O actions

// happen with a socket during a configured number of

// seconds. This implies that the attachment of the

// client socket must implement "GetTimeElapsed()"

// and "ResetTime(...)" methods.

template<class T>

class CTimeOutChecker: public IRunnable {

private:

unsigned int m_nTimeOutValue;

vector<ClientSocket<T> *> *m_arrSocketPool;

IOCPSimple<T> *m_hIocp;

protected:

// method checks sockets to detect time-out cases

virtual void run() {...}

public:

// Constructor of the template class. Requires:

// - a pointer to a collection of pointers to client sockets.

// This is the collection of sockets to be checked against

// time-out cases.

// - a pointer to the IO completion port object responsible

// for checking I/O events against passed collection of

// client sockets.

// - value of the time-out, in seconds.

CTimeOutChecker( vector<ClientSocket<T> *> *arrSocketPool,

IOCPSimple<T> *hIocp, unsigned int nTimeOutValue ) {...}

// Nothing to destruct as inside the template class

// we keep/use just pointers obtained from external

// sources.

~CTimeOutChecker() {};

};

这个类被ServerService 模板类(下面描述)使用，并且，同样的，它的run() 方法将被关联到ServerService的线程池（CSimpleThreadPool）中的一个线程执行，ServerService 也将传递套接字池（关联到ServerService ，通过GetPool()方法）到CTimeOutChecker （的实例）。这样，CTimeOutChecker 知道哪些套接字需要检查。

如果一个超时情况发生，则一个相关的ClientSocket（实例）被传递到IOCP队列，状态是“关闭”。IOCP，早晚会从队列中返回它，并且会将它“传递”给ServerService 。ServerService 将创建一个“事件任务”，并且将它传递给CSimpleThreadPool。“事件任务”，将会被CSimpleThreadPool中的一个线程执行，会“启动”ISockEvent（实现）的OnClose()“事件”，并且会关闭套接字。这就是它如何工作的。

另外，CTimeOutChecker 需要“附件”实现两个额外的方法:GetTimeElapsed() 和ResetTime( bool ).。因此，从技术上来说，CTimeOutChecker 的行为被下面两个方法的实现所控制：

l 如果一个特定的ClientSocket（的附件）的GetTimeElapsed()返回0，则超时情况对ClientSocket不适用，这是一种使指定套接字超时检查无效的方法。

l 尽管ResetTime( bool )的实现可以是任意的（根据开发者而定，必须依据特征）。实际需求是：

Ø 调用ResetTime( true )必须强制后面的GetTimeElapsed()调用返回0。这使得在某一时刻（当需要时）对一个特定套接字的超时检测无效。例如：当写一个Web（HTTP）服务时，当从ClientSocket中等待完成HTTP请求时，有必要开启超时检查。一旦收到完成HTTP请求，有必要关闭相关ClientSocket的超时检查。

Ø 调用ResetTime( false )必须强制后面的GetTimeElapsed()调用返回自动上次调用ResetTime( true )后实际已过去的时间，单位是秒。也就是说，它应该记录当前时间，并且GetTimeElapsed()应该返回当前时间到所记录的时间之间的间隔，以秒为单位。它是由开发者调用ResetTime( false )，当ClientSocket::WriteToSocket()或者ClientSocket::ReadFromSocket()成功完成时（根据服务器的开发策略）。

CTimeOutChecker 的有用之处在哪呢？仅仅是关闭那些经过一段（配置的）时间“没有响应”的套接字，这样可以为其它即将进来的连接释放一些空间（注意ServerSocker 类的nMaxClient参数）。

但是，如果这个逻辑不需要，有一种方式可以使CTimeOutChecker （完全的）无效。仅仅是将ServerService 构造函数的timeout参数设置为0。

10、ISockEvent和ServerService类

最后，让我开始这个结构的核心。如果你没能记住以上所描述的全部细节也是可以的，因为它们全部被封装进ServerService 模板类的逻辑（原因是相同的，“附件”元素），可是，记住第8和第9节是重要的。所有的类在server_service.h文件中被定义。让我们从ServerService 开始：

// Well, finally, here is the template class joining all

// the stuff together. Considering the Aspect Oriented paradigm,

// this template class may be seen as an Aspect. The "individualizations"

// of this aspect are "ISockEvent<T>" and "T" itself. "T" is nothing

// else but attachment of the client socket (see ClientSocket<T> template

// class for more details). Implementing "ISockEvent<T>" and "T" will

// define the individual behaviour of this aspect.

// It is a composition of the IOCP, server socket, time-out checker

// and thread pool. Class implements the business logic that makes all

// these entities working together.

template<class T>

class ServerService: public IRunnable {

private:

ServerSocket<T> m_ServerSocket;

IOCPSimple<T> m_hIocp;

ISockEvent<T> *m_pSEvent;

CTimeOutChecker<T> *m_TChecker;

// thread pool which will execute the tasks

CSimpleThreadPool *m_ThPool;

// a pool of the CSockEventTask<T> objects

QueuedBlocks<CSockEventTask<T> > m_SockEventTaskPool;

protected:

// This method will be executed by a thread

// of the task pool.

virtual void run() {...}

public:

// Constructor or the class.

// pSEvent - pointer to an instance implementing

// ISockEvent<T>. This instance will be used

// as a client socket event handler.

// nPort - port number to bind server socket to.

// nMaxClients - the maximum number of accepted (concurrent)

// client connections. To be passed to

// the server socket and also will be used

// as the initial size for the pool of the

// CSockEventTask<T> objects.

// nNoThreads - indicative (the real one is computed,

// see below) number of the threads

// to be created by the thread pool.

// timeout - the value of the time-out, in seconds.

// Will be passed to the time-out checker.

// If time-out is zero, time-out checker

// will not be created.

// blnBindLocal - see ServerSocket<T> for more details.

// If "true" then server socket is bind

// to localhost ("127.0.0.1").

// If "false" then server socket is bind

// to INADDR_ANY ("0.0.0.0").

ServerService( ISockEvent<T> *pSEvent, unsigned int nPort,

unsigned int nMaxClients, unsigned int nNoThreads,

unsigned int timeout, bool blnBindLocal = true ):

m_ServerSocket( nPort, nMaxClients, true, blnBindLocal ),

m_hIocp( 200 ), m_SockEventTaskPool( nMaxClients )

{...}

virtual ~ServerService() {...}

// Start the threat pool (== all the

// threads in the pool).

void start() {...}

};

这就是ServerService ，没有任何窍门。关于代码的注释应该足够强调响应的逻辑了。所以，我将会集中提供一点关于ISockEvent 模板类的详细信息（实际上，模板接口），该模板类作为一个参数被传递给ServerService 构造函数。

ISockEvent 是一个包含纯虚函数的模板接口：

// A template interface showing how the client socket event

// handler should look like.

template<class T>

class ISockEvent {

public:

// Client socket ("pSocket") is about to be closed.

virtual void OnClose( ClientSocket<T> *pSocket,

MYOVERLAPPED *pOverlap,

ServerSocket<T> *pServerSocket,

IOCPSimple<T> *pHIocp

) = 0;

// Client socket ("pSocket") was just accepted by

// the server socket (new connection with a client

// is created).

virtual void OnAccept( ClientSocket<T> *pSocket,

MYOVERLAPPED *pOverlap,

ServerSocket<T> *pServerSocket,

IOCPSimple<T> *pHIocp

) = 0;

// Client socket ("pSocket") was returned from the IOCP

// queue with status _PENDING. For more details see

// "IOCPSimple<T>::SetPendingMode(...)". This method

// is invoked only if there was a call to

// "IOCPSimple<T>::SetPendingMode(...)", performed by a

// user code, internally "SetPendingMode(...)"

// is never called.

virtual void OnPending( ClientSocket<T> *pSocket,

MYOVERLAPPED *pOverlap,

ServerSocket<T> *pServerSocket,

IOCPSimple<T> *pHIocp

) = 0;

// Client socket ("pSocket") was returned from IOCP

// queue with status _READ. This means that overlapped

// reading operation, started previously with

// "ClientSocket<T>::ReadFromSocket(...)", was

// successfully finished.

// - "pOverlap->DataBuf" structure points to the data

// buffer and buffer's size that were passed to the

// "ClientSocket<T>::ReadFromSocket(...)".

// - "dwBytesTransferred" will indicate how many

// bytes were read.

virtual void OnReadFinalized( ClientSocket<T> *pSocket,

MYOVERLAPPED *pOverlap,

DWORD dwBytesTransferred,

ServerSocket<T> *pServerSocket,

IOCPSimple<T> *pHIocp

) = 0;

// Client socket ("pSocket") was returned from IOCP

// queue with status _WRITE. This means that overlapped

// writting operation, started previously with

// "ClientSocket<T>::WriteToSocket(...)", was

// successfully finished.

// - "pOverlap->DataBuf" structure points to the data

// buffer and buffer's size that were passed to the

// "ClientSocket<T>::WriteToSocket(...)".

// - "dwBytesTransferred" will indicate how many

// bytes were written.

virtual void OnWriteFinalized( ClientSocket<T> *pSocket,

MYOVERLAPPED *pOverlap,

DWORD dwBytesTransferred,

ServerSocket<T> *pServerSocket,

IOCPSimple<T> *pHIocp

) = 0;

};

这个接口的实现（当然还是有“附件”）将定义服务器程序。没有其它的需要被做的...真的！ISockEvent包含了用于跟踪和处理套接字的所有可能的状态所需要的全部方法。让我们来看看：

l 当一个新的连接被ServerSocket接收，ServerSevice将确保OnAccept()事件被调用。它将由开发决定如何处理这个事件。典型的，通过这个事件，你可能发起pSocket->ReadFromSocket()或者pSocket->WriteToSocket()，基于服务器开发的策略（服务器希望客户端发起会话或者反之亦然）。

l 如果一个套接字将要被关闭（远端关闭连接；CTimeOutChecker 发起这个操作，或者你在一个事件的代码中调用了pHIocp->SetCloseMode(pSocket)），然后OnClose()事件被调用。使用这个时间去纸箱任何需要的清理。如果在你没有或者忘记在OnClose()中关闭套接字也是可以的，因为在这个事件完成后，这个套接无论如何是会被关闭的。

l 如果，在一个事件的代码内，pHIocp->SetPendingMode(pSocket)被调用，是的，按上述第8节。确保你使用OnPending()处理了它。

l 如果，在一个事件的代码内（除了OnClose()），pSocket->ReadFromSocket()被调用（并且返回值不是一个错误值），OnReadFinalized()事件将会被调用，一旦“读”操作完成，但是不要指望传递的缓存会被完全填充到缓存的大小。避免在这期间（从ReadFromSocket() 到 OnReadFinalized()）使用已传递的缓冲区。这是从IOCP API继承下来的要求，因此，我们在此不能做任何事情。

l 如果，在一个事件的代码内（除了OnClose()），pSocket->WriteToSocket()被调用（并且返回值不是一个错误值），OnWriteFinalized()事件将会被调用，一旦“写”操作完成。这意味着全部的缓存已经被发出去了。避免在这期间（从WriteToSocket() 到 OnWriteFinalized()）使用已传递的缓冲区，原因如上。

最后，你不需要创建额外的线程，因为每个事件将被关联到ServerService的CSimpleThreadPool中的一个线程调用。如果你需要更多的线程，传递恰当的值给ServerService 的构造函数的nNoThreads 参数。并且，是的，确保每个事件的实现或早或晚的退出。我的意思是，努力避免关于事件的无限循环；否则，停止运行中停止ServerService 会有问题（尽管，如果在循环中检查CThread::currentThread().isInterrupted()仍然存在问题）

最后请那些计划在多核CPU上写服务器的人注意：如果环境中有N个CPU，则恰好CSimpleThreadPool中有N个线程执行ServerService::run()函数，为了获得更好的性能（如MSDN所推荐的那样）。确保你不要在一个事件内多次调用pSocket->ReadFromSocket() 或者 pSocket->WriteToSocket() （尽量设计程序使其只有正确的，没有错误的，祈祷吧）。这并不是说这个架构不能处理重复调用的情况。问题是，虽然发送/接受请求的顺序是保证能够符合调用顺序的（在IOCP队列中），但是报告操作完成的顺序不能够保证符合调用顺序，因为GetQueuedCompletionStatus()会被多线程调用。但是如果你不关心顺序是否正确，可以忽略此点。

11、一个简单模拟服务器的实现

作为一个“技术性验证测试”，让我们实现一个简单的模拟服务器，这个服务器从套接上读取7个字符，并且，一旦缓冲区被填充，将它们发送回去。完成得代码在资源中。

A.首先，让我们定义服务器的参数和缓冲区的大小。

#define BUFF_SIZE 8

#define MAX_CONNECTIONS 10

#define NO_THREADS 4

#define TIME_OUT 10

#define PORT 8080

B.现在，让我们定义“附件”

struct Attachment {

volatile time_t tmLastActionTime;

char sString<BUFF_SIZE>;

DWORD dwStringSize; // current string's size

Attachment() { Clear(); };

bool Commit( DWORD dwBytesTransferred ) {

DWORD dwSize = dwStringSize + dwBytesTransferred;

if ( dwBytesTransferred <= 0 ) return false;

if ( dwSize >= BUFF_SIZE ) return false;

dwStringSize = dwSize;

sString[dwStringSize] = 0;

return true;

};

// as requested by the API of the framework

void Clear() { memset(this, 0, sizeof(Attachment) ); };

// as requested by the API of the framework

void ResetTime( bool toZero ) {

if (toZero) tmLastActionTime = 0;

else {

time_t lLastActionTime;

time(&lLastActionTime);

tmLastActionTime = lLastActionTime;

}

};

// as requested by the API of the framework

long GetTimeElapsed() {

time_t tmCurrentTime;

if (0 == tmLastActionTime) return 0;

time(&tmCurrentTime);

return (tmCurrentTime - tmLastActionTime);

};

C.现在，我们必须实例化模板类

typedef ClientSocket<Attachment> MyCSocket;

typedef ServerSocket<Attachment> MySSocket;

typedef IOCPSimple<Attachment> MyIOCPSimple;

typedef ISockEvent<Attachment> MyISockEvent;

typedef ServerService<Attachment> MyServerService;

D.现在，我们实现ISockEvent<Attachment>:

class MyISockEventHandler: public MyISockEvent {

public:

MyISockEventHandler() {};

~MyISockEventHandler() {};

// empty method, not used

virtual void OnClose( MyCSocket *pSocket, MYOVERLAPPED *pOverlap,

MySSocket *pServerSocket, MyIOCPSimple *pHIocp ) {};

// empty method, not used

virtual void OnPending( MyCSocket *pSocket, MYOVERLAPPED *pOverlap,

MySSocket *pServerSocket, MyIOCPSimple *pHIocp ) {};

virtual void OnAccept( MyCSocket *pSocket, MYOVERLAPPED *pOverlap,

MySSocket *pServerSocket, MyIOCPSimple *pHIocp ) {

int nRet;

DWORD dwSize;

char *temp;

dwSize = BUFF_SIZE - 1;

temp = pSocket->GetAttachment()->sString;

// initiate the reading with OnAccept

nRet = pSocket->ReadFromSocket( temp, dwSize );

pSocket->GetAttachment()->ResetTime( false );

if ( nRet == SOCKET_ERROR ) {

pServerSocket->Release( pSocket );

}

};

virtual void OnReadFinalized( MyCSocket *pSocket,

MYOVERLAPPED *pOverlap, DWORD dwBytesTransferred,

MySSocket *pServerSocket, MyIOCPSimple *pHIocp ) {

int nRet;

DWORD dwSize, dwPos;

char *temp;

// finalize the filling of the buffer

pSocket->GetAttachment()->Commit( dwBytesTransferred );

dwSize = BUFF_SIZE - 1;

dwPos = pSocket->GetAttachment()->dwStringSize;

temp = pSocket->GetAttachment()->sString;

nRet = pSocket->ReadFromSocket( temp + dwPos, dwSize - dwPos );

pSocket->GetAttachment()->ResetTime( false );

if ( nRet == SOCKET_ERROR ) {

pServerSocket->Release( pSocket );

}

else if ( nRet == RECV_BUFFER_EMPTY ) {

// means that dwSize - dwPos == 0, so send the data

// back to the socket

nRet = pSocket->WriteToSocket( temp, dwSize );

if ( nRet == SOCKET_ERROR ) {

pServerSocket->Release( pSocket );

}

};

virtual void OnWriteFinalized( MyCSocket *pSocket,

MYOVERLAPPED *pOverlap, DWORD dwBytesTransferred,

MySSocket *pServerSocket, MyIOCPSimple *pHIocp ) {

// clean the attachment

pSocket->GetAttachment()->Clear();

// and once again

OnAccept(pSocket, NULL,pServerSocket, NULL);

};

E. 并且，最后

int main(int argc, char* argv[])

{

int nRet;

MyServerService *sService;

MyISockEventHandler *mSockHndl;

WSAData wsData;

nRet = WSAStartup(MAKEWORD(2,2),&wsData);

if ( nRet < 0 ) {

Log::LogMessage(L"Can't load winsock.dll./n");

return -1;

}

try {

Overlapped::Init( MAX_CONNECTIONS );

mSockHndl = new MyISockEventHandler();

sService = new MyServerService((MyISockEvent *) mSockHndl,

PORT, MAX_CONNECTIONS, NO_THREADS, TIME_OUT, false);

sService->start();

printf("hit <enter> to stop .../n");

while( !_kbhit() ) ::Sleep(100);

delete sService;

delete mSockHndl;

}

catch (const char *err) {

printf("%s/n", err);

}

catch (const wchar_t *err) {

wprintf(L"%ls/n", err);

}

WSACleanup();

return 0;

}

(本文从本人的另一个CSDN账户上搬移过来)

0 0