[置顶] 发布一套IOCP框架

更新：

2010/08/21

1. 提供MemoryPool支持（详情请查看猛击这里）

2. 模仿asio中io_service服务，把dispatcher接口公开出来，可以post任意回调

3. 增强网络服务端demo

2010/09/07

1. 提供AsyncResult的保存，减少内存申请复制

2. 提供Timer组件，利用WaitableTimer，通过Dispatcher的IOCP线程池进行分派操作

3. 更改一些接口及内部优化

同时，把该套框架放到了Google code上，需要的朋友可以自行下载。

svn：http://iocpframework.googlecode.com/svn/trunk/

压缩包：http://code.google.com/p/iocpframework/downloads/list

 

该框架基于Windows Overlapped IO的完成端口模式。彻底分离了IO线程和Work线程。并且易扩展、易复用、易维护。

目前，所提供的源码提供了Socket和File的异步操作，可以非常方便的扩展为支持其他的操作。

 

编译环境需求：

VS2008+SP1以上（支持C++ tr1组件即可）。

 

大致的层次图如下：

 

类图如下：

 

 

这里，给出的源码和简单的示例(请以所提供的demo程序为准)

#ifndef __SERVICE_HPP
#define __SERVICE_HPP

#include <array>

#include "../../include/network/Socket.hpp"


using namespace async::network;

class Session
    : public std::tr1::enable_shared_from_this<Session>
{
private:
    SocketPtr socket_;
    SocketBufferPtr data_;

public:
    Session(const SocketPtr &sock)
        : socket_(sock)
        , data_(new SocketBuffer)
    {
    }
    ~Session()
    {
        Stop();
    }
    SocketPtr& GetSocket()
    {
        return socket_;
    }

    void Start()
    {
        try
        {        
            socket_->BeginRecv(data_, 0, data_->allocSize(), std::tr1::bind(&Session::_HandleRead, shared_from_this(), std::tr1::placeholders::_1));
        }
        catch(std::exception &e)
        {
            std::cerr << e.what() << std::endl;
        }
    }

    void Stop()
    {
        socket_->Close();
    }

private:
    void _HandleRead(const AsyncResultPtr &asyncResult)
    {
        try
        {
            size_t bytes = socket_->EndRecv(asyncResult);
            if( bytes == 0 )
            {
                socket_->BeginDisconnect(true, std::tr1::bind(&Session::_DisConnect, shared_from_this(), std::tr1::placeholders::_1));
                return;
            }

            data_->resize(bytes);
            socket_->BeginSend(data_, 0, data_->size(), std::tr1::bind(&Session::_HandleWrite, shared_from_this(), std::tr1::placeholders::_1));
        }
        catch(const std::exception &e)
        {
            std::cerr << e.what() << std::endl;
        }
    }

    void _HandleWrite(const AsyncResultPtr &asyncResult)
    {
        Start();
    }

    void _DisConnect(const AsyncResultPtr &asyncResult)
    {
        Stop();
    }
};

typedef std::tr1::shared_ptr<Session> SessionPtr;


class Server
{
private:
    IODispatcher &io_;
    SocketPtr acceptor_;

public:
    Server(IODispatcher &io, short port)
        : io_(io)
        , acceptor_(new Socket(io_))
    {
        acceptor_->Bind(port);
        acceptor_->Listen();
    }

    ~Server()
    {
        _StopServer();
    }

public:
    void Start()
    {
        _StartAccept();
    }

    void Stop()
    {
        _StopServer();
    }

private:
    void _StartAccept()
    {        
        try
        {
            acceptor_->BeginAccept(std::tr1::bind(&Server::_OnAccept, this, std::tr1::placeholders::_1));
        } 
        catch(const std::exception &e)
        {
            std::cerr << e.what() << std::endl;
        }
    }

    void _StopServer()
    {
        acceptor_->Close();
    }

private:
    void _OnAccept(const AsyncResultPtr &asyncResult)
    {
        try
        {
            if( *acceptor_ == INVALID_SOCKET )
                return;

            SocketPtr acceptSocket = acceptor_->EndAccept(asyncResult);

            SessionPtr session_(new Session(acceptSocket));
            session_->Start();

            _StartAccept();
        }
        catch(const std::exception &e)
        {
            std::cerr << e.what() << std::endl;
        }
    }
};



#endif

int main(int argc, char* argv[])
{
    _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);

    IODispatcher ioService(GetFitThreadNum());

    try
    {
        Server server(ioService, 5050);
        server.Start();

        system("pause");
    }
    catch(std::exception &e)
    {
        std::cerr << e.what() << std::endl;
    }

    system("pause");
    return 0;
}

当然，还有许多可以改进的地方，希望大家多多指教。

这里是下载的链接。（不建议使用此版本代码）