reactor模式C++實現

阿新 • • 發佈：2019-01-03

copy from github上的一份實現。。。找不到連結了。。。
* epoll主要負責fd到event型別的對映
* EventDemultiplexer管理fd <-> event型別 <-> eventhandler具體怎麼做event的回撥方法，從而間接實現fd <–event型別–> eventhandler
的具體回撥方法方法
* Reactor負責註冊、管理、分配

核心程式碼

reactor.h

#include "event_handler.h"
#include "event.h"
#include "reactor_impl.h" 


class ReactorImpl; // 為了隱藏具體實現麼。。

class Reactor {
public:
    static Reactor& get_instance();
    int regist(EventHandler* handler, Event evt);
    void remove(EventHandler* handler);
    void dispatch(int timeout = 0);

private:
    Reactor();
    ~Reactor();
    Reactor(const Reactor&);
    Reactor& operator 
=(const Reactor&);

private:
    ReactorImpl* _reactor_impl;
    static Reactor reactor;
};

reactor.cpp

#include "reactor.h"
#include <assert.h>
#include <new>

Reactor Reactor::reactor;

Reactor& Reactor::get_instance() {
    return reactor;
}

Reactor::Reactor() {
    _reactor_impl = new 
 (std::nothrow)ReactorImpl();
    assert(_reactor_impl != NULL);
}

Reactor::~Reactor() {
    if (_reactor_impl != NULL) {
        delete _reactor_impl;
        _reactor_impl = NULL;
    }
}


int Reactor::regist(EventHandler* handler, Event evt) {
    return _reactor_impl->regist(handler, evt);
}

void Reactor::remove(EventHandler* handler) {
    return _reactor_impl->remove(handler);
}

void Reactor::dispatch(int timeout) {
    return _reactor_impl->dispatch(timeout);
}

reactor_impl.h

#include <map>
#include "event.h"
#include "event_handler.h"
#include "event_demultiplexer.h"

class ReactorImpl {
public:
    ReactorImpl();
    ~ReactorImpl();
    int regist(EventHandler* handler, Event evt);
    void remove(EventHandler* handler);
    void dispatch(int timeout = 0);

private:
    EventDemultiplexer* _demultiplexer;
    std::map<Handle, EventHandler*> _handlers;
};

reactor_impl.cpp

#include "reactor_impl.h"
#include <new>
#include <assert.h>
#include "epoll_demultiplexer.h"

ReactorImpl::ReactorImpl() {
    _demultiplexer = new (std::nothrow)EpollDemultiplexer();
    assert(_demultiplexer != NULL);
}

ReactorImpl::~ReactorImpl() {
    std::map<Handle, EventHandler*>::iterator iter = _handlers.begin();
    for(; iter != _handlers.end(); ++iter) {
        delete iter->second;
    }

    if (_demultiplexer != NULL) {
        delete _demultiplexer;
    }
}

int ReactorImpl::regist(EventHandler* handler, Event evt) {
    int handle = handler->get_handle();
    if (_handlers.find(handle) == _handlers.end()) {
        _handlers.insert(std::make_pair(handle, handler));
    }
    return _demultiplexer->regist(handle, evt);
}

void ReactorImpl::remove(EventHandler* handler) {
    int handle = handler->get_handle();
    // not check?
    _demultiplexer->remove(handle);

    std::map<Handle, EventHandler*>::iterator iter = _handlers.find(handle);
    delete iter->second;
    _handlers.erase(iter);
}

void ReactorImpl::dispatch(int timeout) {
    _demultiplexer->wait_event(_handlers, timeout);
}

event.h

typedef unsigned int Event;
enum EventMask {
    ReadEvent  = 0x01,
    WriteEvent = 0x02,
    ErrorEvent = 0x04,
    EventMask  = 0xff
};

event_demultiplexer.h

#include <map>
#include "event_handler.h"
#include "event.h"

class EventDemultiplexer {
public:
    EventDemultiplexer() {}
    virtual ~EventDemultiplexer()  {}
    virtual int wait_event(std::map<Handle, EventHandler*>& handlers, int timeout = 0) = 0;
    virtual int regist(Handle handle, Event evt) = 0;
    virtual int remove(Handle handle) = 0;
};

epoll_demultiplexer.h

#include <map>
#include "event_handler.h"
#include "event.h"
#include "event_demultiplexer.h"

class EpollDemultiplexer : public EventDemultiplexer {
public:
    EpollDemultiplexer();
    virtual ~EpollDemultiplexer();
    virtual int wait_event(std::map<Handle, EventHandler*>& handlers, int timeout = 0);
    virtual int regist(Handle handle, Event evt);
    virtual int remove(Handle handle);
private:
    int _max_fd;
    int _epoll_fd;
};

epoll_demultiplexer.cpp

#include <vector>
#include <sys/epoll.h>
#include <iostream>
#include <errno.h>
#include <unistd.h>

#include "epoll_demultiplexer.h"

EpollDemultiplexer::EpollDemultiplexer() : _max_fd(0) {
    _epoll_fd = epoll_create(1024);
}

EpollDemultiplexer::~EpollDemultiplexer() {
    close(_epoll_fd);
}

int EpollDemultiplexer::wait_event(std::map<Handle, EventHandler*>& handlers, int timeout) {
    std::vector<struct epoll_event> events(_max_fd);
    int num = epoll_wait(_epoll_fd, &events[0], _max_fd, timeout);
    if (num < 0) {
        //std::cerr << "WARNING: epoll_wait error " << errno << std::endl;
        return num;
    }

    for (int i = 0; i < num; ++i) {
        Handle handle = events[i].data.fd;
        if ((EPOLLHUP|EPOLLERR) & events[i].events) {
            assert(handlers[handle] != NULL);
            (handlers[handle])->handle_error();
        } else {
            if ((EPOLLIN) & events[i].events) {
                assert(handlers[handle] != NULL);
                (handlers[handle])->handle_read();
            }
            if (EPOLLOUT & events[i].events) {
                (handlers[handle])->handle_write();
            }
        }
    }
    return num;
}

int EpollDemultiplexer::regist(Handle handle, Event evt) {
    struct epoll_event ev;
    ev.data.fd = handle;
    if (evt & ReadEvent) {
        ev.events |= EPOLLIN;
    }
    if (evt & WriteEvent) {
        ev.events |= EPOLLOUT;
    }
    ev.events |= EPOLLET;

    if (epoll_ctl(_epoll_fd, EPOLL_CTL_ADD, handle, &ev) != 0) { 
        if (errno == ENOENT) {
            if (epoll_ctl(_epoll_fd, EPOLL_CTL_ADD, handle, &ev) != 0) {
                std::cerr << "epoll_ctl add error " << errno << std::endl;
                return -errno;
            }
            ++_max_fd;
        } else {
            ++_max_fd;
        }
    }
    return 0;
}

int EpollDemultiplexer::remove(Handle handle) {
    struct epoll_event ev;
    if (epoll_ctl(_epoll_fd, EPOLL_CTL_DEL, handle, &ev) != 0) {
        std::cerr << "epoll_ctl del error" << errno << std::endl;
        return -errno;
    }
    --_max_fd;
    return 0;
}

event_handler.h

typedef int Handle;

class EventHandler {
public:
    EventHandler() {}
    virtual ~EventHandler() {}
    virtual Handle get_handle() const = 0;
    virtual void handle_read() = 0;
    virtual void handle_write() = 0;
    virtual void handle_error() = 0;
};

listen_handler.h

#include "event_handler.h"
#include "event.h"

class ListenHandler : public EventHandler {
public:
    ListenHandler(Handle fd);
    virtual ~ListenHandler();
    virtual Handle get_handle() const {
        return _listen_fd;
    }
    virtual void handle_read();
    virtual void handle_write();
    virtual void handle_error();
private:
    Handle _listen_fd;
};

listen_handler.cpp

#include "listen_handler.h"
#include <unistd.h>
#include <sys/socket.h>
#include <stdio.h>
#include <new>
#include <assert.h>
#include "event_handler.h"
#include "reactor.h"
#include "socket_handler.h"

ListenHandler::ListenHandler(Handle fd) : _listen_fd(fd) {
    // do nothing
}

ListenHandler::~ListenHandler() {
    close(_listen_fd);
}

void ListenHandler::handle_read() {
    int fd = accept(_listen_fd, NULL, NULL);
    EventHandler* h = new (std::nothrow)SocketHandler(fd);
    assert(h != NULL);
    Reactor& r = Reactor::get_instance();
    r.regist(h, ReadEvent);
}

void ListenHandler::handle_write() {
    // do nothing
}

void ListenHandler::handle_error() {
    // do nothing
}

socket_handler.h

#include "event_handler.h"
#include "event.h"

class SocketHandler : public EventHandler {
public:
    SocketHandler(Handle fd);
    virtual ~SocketHandler();
    virtual Handle get_handle() const {
        return _socket_fd;
    }
    virtual void handle_read();
    virtual void handle_write();
    virtual void handle_error();
private:
    Handle _socket_fd;
    char* _buf;
    static const int MAX_SIZE = 1024;
};

socket_handler.cpp

#include "socket_handler.h"
#include <string.h>
#include <stdio.h>
#include <assert.h>
#include <unistd.h>
#include <sys/socket.h>
#include <stdio.h>
#include <new>
#include "reactor.h"

SocketHandler::SocketHandler(Handle fd) :
        _socket_fd(fd) {
    _buf = new (std::nothrow)char[MAX_SIZE];
    assert(_buf != NULL);
    memset(_buf, 0, MAX_SIZE);
}

SocketHandler::~SocketHandler() {
    close(_socket_fd);
    delete[] _buf;
}

void SocketHandler::handle_read() {
    if (read(_socket_fd, _buf, MAX_SIZE) > 0) {
        write(_socket_fd, _buf, strlen(_buf));
    } 
    handle_error();
}

void SocketHandler::handle_write() {
    // do nothing
}

void SocketHandler::handle_error() {
    Reactor& r = Reactor::get_instance();
    r.remove(this);
}

demo

client.cpp

#include "sys/socket.h"
#include <arpa/inet.h>
#include <sys/socket.h>
#include <iostream>
#include <errno.h>
#include "reactor.h"
#include "event_handler.h"
#include "listen_handler.h"
#include "event.h"

int main() {
    int socketfd = -1;
    if ( (socketfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        std::cerr << "socket error " << errno << std::endl;
        exit(-1);
    }

    struct sockaddr_in seraddr;
    seraddr.sin_family = AF_INET;
    seraddr.sin_port = htons(53031);
    seraddr.sin_addr.s_addr = inet_addr("127.0.0.1"); // TODO

    if (connect(socketfd, (struct sockaddr*)&seraddr, sizeof(seraddr)) < 0) {
        std::cerr << "connect error " << errno << std::endl;
        exit(-2);
    }

    char wbuf[64] = {0};
    strcpy(wbuf, "hello world");
    int n = write(socketfd, wbuf, strlen(wbuf));

    char rbuf[64] = {0};
    memset(rbuf, 0, sizeof(rbuf));
    n = read(socketfd, rbuf, sizeof(rbuf));
    std::cout << "send [" << wbuf << "] reply [" << rbuf << "]" << std::endl;

    if (n < 0) {
        std::cerr << "read error " << errno << std::endl;
        exit(-3);
    }
    close(socketfd);
    return 0;

    Reactor& actor = Reactor::get_instance();
    EventHandler* handler = new ListenHandler(socketfd);
    actor.regist(handler, ReadEvent);

    while(true) {
        actor.dispatch(-1);
        std::cout << "client one loop" << std::endl;
    }

    return 0;
}

server.cpp

#include <sys/socket.h>
#include <arpa/inet.h>
#include <iostream>
#include <errno.h>
#include "reactor.h"
#include "event_handler.h"
#include "listen_handler.h"
#include "event.h"

int main() {
    int listenfd = -1;
    if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        std::cerr << "socket error " << errno << std::endl;
        exit(-1);
    }

    struct sockaddr_in seraddr;
    seraddr.sin_family = AF_INET;
    seraddr.sin_port = htons(53031);
    seraddr.sin_addr.s_addr = htonl(INADDR_ANY);

    if (bind(listenfd, (struct sockaddr*)&seraddr, sizeof(seraddr)) < 0) {
        std::cerr << "bind error " << errno << std::endl;
        exit(-2);
    }

    if (listen(listenfd, 5) < 0) {
        std::cerr << "listen error " << errno << std::endl;
        exit(-3);
    }

    Reactor& actor = Reactor::get_instance();
    EventHandler* handler = new ListenHandler(listenfd);
    actor.regist(handler, ReadEvent);

    while(true) {
        actor.dispatch(100);
        //std::cout << "one loop" << std::endl;
    }

    return 0;
}

reactor模式C++實現

copy from github上的一份實現。。。找不到連結了。。。 * epoll主要負責fd到event型別的對映 * EventDemultiplexer管理fd <-> event型別 <-> eventhandler具體怎麼

設計模式C++實現——工廠方法模式

對象類型 begin 創建對象 dia rate rod rtu log 模式定義：工廠方法模式定義了一個創建對象的接口，但由子類決定要實例化的類是哪一個。工廠方法讓類把實例化推遲到子類。模式結構： Creator是一個類，它

大話設計模式C++實現-第17章-適配器模式

req span oid efi cpp endif 對象 adapt sdn 一、UML圖關鍵詞：Client須要Request（）函數，Adaptee提供的是SpecificRequest（）函數，Adapter提供一個Request（）函數將Ada

HeadFirst設計模式---策略模式 C#實現

模式 adf oid info wing face rmq protected src 鴨子基類將行為封裝起來 class Duck { protected IFlyBehavior flyBehavior; protec

代理模式C++實現

#include <iostream> #include <string&

裝飾模式C++實現

#include <iostream> #include <string> class Person

策略模式模式C++實現

策略模式：當用戶需要選擇不同的演算法或行為時，如果把這些演算法或行為寫在一個類裡，通過判斷來選擇的話，這個類將變得非常複雜並且難以維護。策略模式就是構造一個抽象類，具體的演算法或者行為繼承這個類，讓使用者來選擇。這樣做的好處是，可以隨時增加或者修改行為，即增加、修改演算法或行為的類就可以了。

簡單工廠模式C++實現

<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);">面向物件的優點：</span> 1、可維護：修改簡單 2、可複用：

策略模式——C++實現

策略模式其實和簡單工廠模式很相似，在看《大話設計模式》這本書時，一開始也是一度弄混這兩個模式，關於簡單工廠模式的一個介紹以及C++程式碼可以參考上一篇文章點選開啟連結。策略模式和簡單工廠模式最主要的區別在於客戶端使用者需要操作幾個類，下面仍以加、減、乘、除計算來講解：在上簡單工廠模式中，

大話設計模式C++實現-第3.4.5-設計原則（1）

第三章-單一職責原則（1）.就一個類而言，應該僅有一個引起它變化的原因。（2）如果一個類承擔的職責過多，就等於把這些職責耦合在了一起，一個職責的變化可能會削弱或者抑制這個類完成其他職責的能力。這種耦合會導致脆弱的設計，當發生變化時，設計會遭受到意想不到的破壞。（3）軟體設計真正要做

05：原型模式——C++實現

目錄一、介紹二、應用場景三、要點四、樣例五、優缺點一、介紹原型模式（Prototype Pattern）是用於建立重複的物件，同時又能保證效能。這種型別的設計模式屬於建立型模式，它提供了一種建立物件的最佳方式。

04：工廠模式——C++實現

目錄一、簡介二、應用場景三、要點四、樣例五、優缺點一、簡介工廠模式（Factory Pattern）：定義一個建立物件的介面，讓其子類自己決定例項化哪一個工廠類，工廠模式使其建立過程延遲到子類進行。主要解決介面選擇的問題。此模式的核心思想是封裝類中不

03：建造者模式——C++實現

目錄一、介紹二、應用場景三、要點四、樣例五、優缺點一、介紹建造者模式（Builder Pattern）使用多個簡單的物件一步一步構建成一個複雜的物件。這種型別的設計模式屬於建立型模式，它提供了一種建立物件的最佳方式。將一個複雜的構建與其表示相分離，使

02：抽象工廠模式——C++實現

目錄一、介紹二、應用場景三、要點四、樣例 1、建立抽象產品 2、建立具體產品 3、建立抽象工廠 4、建立具體工廠 5、建立客戶端五、優缺點一、介紹抽象工廠模式（Abstract Factory

01：單例模式——C++實現

目錄一、介紹二、應用場景三、要點四、樣例Demo 4.1、區域性靜態變數 4.2、懶漢式與餓漢式懶漢式餓漢式 4.3、執行緒安全 4.4、資源釋放五、優缺點優點缺點：一、介紹

設計模式-單例模式-C++實現

單例模式：保證一個類提供且僅提供一例項，並提供一個訪問它的全域性訪問點。場景： 1.當類只能有一個例項並且客戶可以從一個公共的介面訪問到例項； 2.當這個唯一的例項應該是通過子類化可擴充套件的，並且客戶應該無需更改程式碼就能使用一個擴充套件的例項。 #include <s

設計模式-組合模式-C++實現

組合模式：將物件組合成屬性結構以表示“部分-整體”的層次結構，是的客戶端對單個物件的和組合物件具有一直的組合方式。場景： 1.想表示整體-部分的層次關係； 2.希望忽略組合物件和單個物件的不同，使用者統一使用組合結構中的所有物件。 #include <stdio.h>

設計模式-策略模式-C++實現

策略模式：定義一系列的演算法，把他們一個個封裝起來，並且使他們可以相互替換，使得演算法可獨立於使用它的客戶而變化。場景： 1.許多相關的類僅僅是行為上優異； 2.需要一個算髮的不同實現； 3.一個類中定義了多種行為，並且以多個條件語句的形式出現。例子：北京公交卡的使用，在小

設計模式-模板模式-C++實現

模板模式：定義一個操作的演算法和骨架，而將一些步驟延遲到子類中。使得子類可以不改變一個演算法的結構的情況下可以重新定義這個演算法的一些步驟。比如：炒菜這件事情就有統一的步驟，先放油再放調料加火炒菜，這個固定不變的。而且順序也是不變的。但是炒不同的菜加油的多少，火候的掌握是不相同的

設計模式-建造者模式-C++實現

建造者模式：將一個複雜物件的構建與它的表示分離，使得同樣的建立過程可以建立不同的表示。場景： 1.當建立複雜物件的演算法應該獨立於該物件的組成部分以及它們的裝配方式時。 2.當構造過程必須允許被建立的物件有不同的表示時。 #include <stdio.h> #in

reactor模式C++實現

核心程式碼

demo

相關推薦