文章目录
全文约 8696 字，预计阅读时长： 25分钟
Reactor反应堆模式
Reactor：负责检测关心的IO事件，当检测到IO事件时，分发给Handlers处理（对数据的读写处理+对数据的分析处理）。epoll ET工作方式：只支持非阻塞IO文件。
简易的Reactor epoll ET TCP服务器
单进程基于ET非阻塞设计的一个Reactor模式+数据读写+数据分析。
socket封装
监听套接字的创建、绑定、监听、设置非阻塞I/O
#pragma once
#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <strings.h>
#include<fcntl.h>
using std::cerr;
using std::cin;
using std::cout;
using std::endl;
namespace ns_sock
{
enum
{
SOCK_ERR = 2,
BIND_ERR,
LISTEN_ERR
};
const int g_backlog = 5;
struct sock_package
{
static int SockCreate()
{
int sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock < 0)
{
cerr << "socket failed" << endl;
exit(SOCK_ERR);
}
//设置可以立即重启绑定。
int opt = 1;
setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
return sock;
}
static void Bind(const int &sock_fd, const uint16_t &port)
{
struct sockaddr_in local;
bzero(&local, sizeof(local));
local.sin_addr.s_addr = INADDR_ANY;
local.sin_port = htons(port);
local.sin_family = AF_INET;
if (bind(sock_fd, (sockaddr *)&local, sizeof(local)) < 0)
{
cerr << "Bind Error" << endl;
exit(BIND_ERR);
}
}
static void Listen(const int &sock_fd)
{
if (listen(sock_fd, g_backlog) < 0)
{
cerr << "Listen Error" << endl;
exit(LISTEN_ERR);
}
}
static void set_noblock(int listen_sk)
{
int ret_sock = fcntl(listen_sk,F_GETFL);
if(ret_sock<0)
{
cerr<<"fcntl error"<<endl;
exit(5);
}
fcntl(listen_sk,F_SETFL,ret_sock | O_NONBLOCK);
}
};
}
epoll。hpp
一：epoll文件描述符的创建，往epoll文件描述里、添加需要关心的I/O文件 、以及关心的I/O文件的事件；检测事件的发生。
二：当前I/O文件的错误回调功能具有：哈希表删除当前的fd值，epoll_del从epoll红黑树中删除该fd节点；最后关闭fd。
三：检测到所有的异常事件发生时，都交付给当前I/O文件的错误回调处理。
四：当检测有事件就绪时应检测当前I/O文件的FD是否还存在。因为可能发送事件触发时，上一秒该文件有异常，从epoll中删除了。
五：具有一个可以让：当前I/O文件读取完毕后，构建发送报文时，可以修改当前该文件的关心事件的功能。因为读事件时一直需要关心的，写事件需要服务器返回数据时开启，发送完毕取消关心。sock文件描述符的反应堆指针，是为了后续可以使用其内部相关功能。
#pragma once
#include <iostream>
#include <sys/epoll.h>
#include <unordered_map>
#include <string>
#include <utility>
#include <unistd.h>
using namespace std;
namespace ns_reactor
{
class reactor_sv;
class sock_pack;
typedef void (*sock_callback)(sock_pack &);//函数指针类型
class sock_pack//sock_fd配套设施。
{
public:
int sock_fd_;
reactor_sv *r;
string inbuffer;
string outbuffer;
sock_callback read_hand;//函数指针类型 声明 一个函数指针
sock_callback write_hand;
sock_callback error_hand;
public:
sock_pack() : sock_fd_(-1), r(nullptr)
{
read_hand = nullptr;
write_hand = nullptr;
error_hand = nullptr;
}
~sock_pack()
{
// if (sock_fd_ >= 0)
// {
// close(sock_fd_);
// }
cout << "dont Deconstruction me" << endl;
}
void sock_events_handler(sock_callback rc, sock_callback wc, sock_callback ec)
{
read_hand = rc;//函数指针格式一样即可。
write_hand = wc;
error_hand = ec;
}
};
----------
class reactor_sv//反应堆核心
{
private:
int epfd_;
unordered_map<int, sock_pack> react_mp;
public:
reactor_sv() : epfd_(-1)
{
}
~reactor_sv() {}
void epfd_create()//创建
{
epfd_ = epoll_create(128);
if (epfd_ < 0)
{
cerr << "epoll create error..." << endl;
return;
}
cout << "初始化完成..." << endl;
}
void epll_add(const sock_pack &sk, const uint32_t ext_events)//添加sock——fd至epoll中
{
epoll_event ske;
ske.events = ext_events;
ske.data.fd = sk.sock_fd_;
if (epoll_ctl(epfd_, EPOLL_CTL_ADD, sk.sock_fd_, &ske) < 0)
{
cerr << "epol_ctl failed.." << endl;
return;
}
else
{
react_mp.insert({sk.sock_fd_, sk});
}
cout << "ep_add success...!" << endl;
}
void Epoll_Del(int sock)//出错清除关心的IO文件。
{
auto iter = react_mp.find(sock);
if (iter == react_mp.end())
{
return;
}
epoll_ctl(epfd_, EPOLL_CTL_DEL, sock, nullptr);
react_mp.erase(iter);
close(sock);
cout << "Epoll_Del called..资源清理成功" << endl;
}
//当读取完毕修改写事件的关心。发送完毕以后，对写事件的取消关注。
void EventMod(int sock, bool isread, bool iswrite)
{
epoll_event ev;
ev.events = (EPOLLET | (isread ? EPOLLIN : 0) | (iswrite ? EPOLLOUT : 0));
ev.data.fd = sock;
if (epoll_ctl(epfd_, EPOLL_CTL_MOD, sock, &ev) == 0)
{
cout << "EventMod success!..." << endl;
}
}
bool Is_Exits(int sock)//判断fd是否还在。
{
auto iter = react_mp.find(sock);
return iter == react_mp.end() ? false : true;
}
#define NUM 10
//事件就绪时的事件派发
void dispather(int &timeout)
{
epoll_event epev[NUM];
int n = epoll_wait(epfd_, epev, NUM, timeout);//检测
for (size_t i = 0; i < n; i++)
{
// cout << "epoll_wait ready...!" << endl;
uint32_t events1 = epev[i].events;
int sock1 = epev[i].data.fd;
//所有的异常交给sock的错误回调
if (events1 & EPOLLERR)
{
events1 |= (EPOLLIN | EPOLLOUT);
}
if (events1 & EPOLLHUP)//客户挂断
{
events1 |= (EPOLLIN | EPOLLOUT);
}
if ((Is_Exits(sock1)) && (events1 & EPOLLIN))
if (react_mp[sock1].read_hand)
react_mp[sock1].read_hand(react_mp[sock1]);
if ((Is_Exits(sock1)) && events1 & EPOLLOUT)
if (react_mp[sock1].write_hand)
react_mp[sock1].write_hand(react_mp[sock1]);
}
}
};
}
epoll。cc
申请一个反应堆核心。创建绑定套接字。该文件相关设施的配置。堆核心的创建，添加、循环检测。
最开始添加的是监听套接字相关。
#include "epoll.hpp"
#include "sock.hpp"
#include "Accept.hpp"
using namespace ns_sock;
using namespace ns_reactor;
int main()
{
//动态开辟一个反应堆核心
reactor_sv *re_sv = new reactor_sv;
//创建监听套接字
int listen_sock_ = sock_package::SockCreate();
sock_package::Bind(listen_sock_, 8080);
sock_package::Listen(listen_sock_);
sock_package::set_noblock(listen_sock_);
//创建一个sock相关的对象
sock_pack sk;
sk.sock_fd_ = listen_sock_;
sk.r = re_sv;
sk.sock_events_handler(accpt_listen, nullptr, nullptr);
//堆核心初始化，添加需要关心的套接字文件以及读写事件
re_sv->epfd_create();
re_sv->epll_add(sk, EPOLLIN | EPOLLOUT);
int time1 = 1000;
//cout << "开始循环服务 " << endl;
while (true)
{
//循环检测就绪队列是否有事件就绪
//sleep(2);
re_sv->dispather(time1);
}
// re_sv->dispather(time1);
return 0;
}
Accept。hpp连接器
有连接到来时，添加进epoll中，设置新连接相关属性。
#pragma once
#include "sock.hpp"
#include "epoll.hpp"
#include "Awe_call.hpp"
using namespace ns_sock;
using namespace ns_reactor;
void accpt_listen(sock_pack &sk)
{
while (true)
{
//cout << "获取客户套接字..." << sk.sock_fd_ << endl;
sockaddr_in peer;
socklen_t len = sizeof(peer);
int sock1 = accept(sk.sock_fd_, (sockaddr *)&peer, &len);
if (sock1 > 0) //新连接
{
sock_pack new_sk;
sock_package::set_noblock(sock1);
new_sk.sock_fd_ = sock1;
new_sk.r = sk.r;
new_sk.sock_events_handler(read_call, write_call, error_call);
(sk.r)->epll_add(new_sk, EPOLLIN | EPOLLET);
cout<<"添加的套接字:..."<<sock1<<endl;
}
else //全局错误码被设置
{
if (errno == EINTR)
{
continue; //被信号中断，并不代表底层没有新连接。
}
else if (errno == EAGAIN || errno == EWOULDBLOCK)
{
//错误码这样的是因为 底层没有链接了。
break;
}
else
{
//真错了
cerr << "accept error..." << endl;
continue;
}
}
}
}
读事件就绪回调
按照协议对接收到的报文进行读取。模拟协议：100+100X120+120X；X是报文之间的分隔符；网络计算器。这里只考虑加法。
一：一个函数只负责专心读。从网络sock中读取到自己的输入缓冲区中。
二：一个函数对批量读取到的数据进行粘包问题处理，分成多个报文。
三：再对单个报文进行分析。
四：分析完毕，计算结果。
五：发送响应给客户端；实际是写入到自己的输出缓冲区。
六：自己文件关心事件修改：关心写入事件（send）。
出错则调用己方的错误回调。
专心负责读。
static int ReadHelp(sock_pack &sk)
{
while (true)
{
char buff[1024];
ssize_t s = recv(sk.sock_fd_, buff, sizeof(buff) - 1, 0);
if (s > 0)
{
buff[s] = 0;
sk.inbuffer += buff;
}
else if (s < 0)
{
if (errno == EINTR) //信号错误
{
continue;
}
else if (errno == EAGAIN || errno == EWOULDBLOCK)
{
return 0; //把数据读完了。
}
else
{
return -1;
}
}
else // == 0 客户端下线
{
return -1;
}
}
}
// 1+1 分析单个报文 x，y，op、输入输出参数
static bool AnalyseData(string &scut, int *x, int *y, char *op)
{
auto pos = scut.find("+");
if (pos == string::npos)
{
return false;
}
*x = atoi(scut.substr(0, pos).c_str()); //[)不包含pos
*y = atoi(scut.substr(pos + 1).c_str());
*op = '+';
return true;
}
//缓冲区数据分成多个报文
//输入输出参数：vector<string> *out
static void StringUncouple(string &in, vector<string> *out, const string &op)
{
while (true)
{
auto pos = in.find(op);
if (pos == string::npos)
{
break;
}
string sub = in.substr(0, pos);
out->push_back(sub);
in.erase(0, pos + op.size());
}
}
void read_call(sock_pack &sk)
{
// cout<<"ready to read.."<<endl;
//专心负责读。出错了你告诉我。我使用错误回调。-1 失败 0 完全读完
if (ReadHelp(sk) < 0)
{
if (sk.error_hand)
sk.error_hand(sk);
return;
}
//缓冲区数据分成多个报文 1+1X2+3X...x切割符
vector<string> msgcut;
StringUncouple(sk.inbuffer, &msgcut, "X");
//分析单个报文
for (auto &scut : msgcut)
{
//反序列化
// Task t(sk.sock_, scut); 也可以采用线程池的方法
// ThreadPool.push(t);
int x = 0;
int y = 0;
char op = 0;
if (!AnalyseData(scut, &x, &y, &op))
{
continue;
}
//计算结果。
int result = 0;
switch (op)
{
case '+':
result = x + y;
break;
default:
break;
}
//构建单个响应报文
string res = scut;
res += "=";
res += to_string(result);
res += "X"; //添加分隔符
//发送
sk.outbuffer += res;
//设置写事件关心
(sk.r)->EventMod(sk.sock_fd_, true, true);
}
}
写事件就绪回调
发送时区分：自己的输出缓冲区是否全部发送完毕，是则清空；取消对写入事件的关心。
因为TCP发送缓冲区导致的，己方发送缓冲区未发送完毕，则清空己方书输出缓冲区已经发送的内容。还需持续关心写事件。
出错则调用己方的错误回调。
static int SendHelp(int sock,string& wrt_string)
{
int total =0;//一共发了多少个字节
int size= wrt_string.size();
//防止协议缓冲区满了，而自己缓冲区还有数据，删除已经发送的。
const char* start = wrt_string.c_str();
while (true)
{
//实际上发送的字节数是取决于返回值
ssize_t s = send(sock,start+total,size-total,0);
if(s>0)
{
total+=s;
if(total == size)
{
wrt_string.clear();
return 1;
}
}
else //错误的几种情况
{
if(errno == EINTR)//信号错误
{
continue;
}
else if(errno == EAGAIN || errno == EWOULDBLOCK)
{
//TCP发送缓冲区满了。清除已经发送的了。
wrt_string.erase(0,total);
return 0;
}
else
{
return -1;
}
}
}
}
void write_call(sock_pack &sk)
{
//cout << "ready to write.." << endl;
//-1，失败；1，发送完毕；0，未完全发送。
int ret = SendHelp(sk.sock_fd_, sk.outbuffer);
if (ret == -1)
{
if (sk.error_hand)
sk.error_hand(sk);
}
else if(ret ==1)//发送完毕
{
(sk.r)->EventMod(sk.sock_fd_,true,false);
}
else if(ret == 0)//需持续关心写事件就绪，一旦就绪就可以从自己缓冲区发。
{
(sk.r)->EventMod(sk.sock_fd_,true,true);
}
}
错误事件回调
调用核心中的Epoll_Del函数。
void error_call(sock_pack &sk)
{
cout << " error_call..." << endl;
sk.r->Epoll_Del(sk.sock_fd_);
}
总结与拓展
substr()：前必后开[)，返回起始位置到end参数（或直到字符串的结尾）的string对象。vector：push_back()、auto for...，容器的find使用。- 有一个意义清晰的变量命名和函数名。函数名首字母大写，下划线，首字母大写…
Acceptor_Connector。 - 根据接受、发送错误时；全局错误码的设置。采取对应的处理方式。一般情况是：信号错误继续；网络套接字接受区的数据读完了，返回；发送缓冲区满了，清楚己方输出缓冲区的数据。
- 线程池、任务队列、多进程、多线程的考虑；STL容器及其功能的熟悉。
拓展
- 格言：All problems in computer science can be solved by another level of indirection.。计算机科学中的所有问题都可以通过增加一个间接层来解决。—David Wheeler（剑桥大学计算机科学教授）
- epoll的惊群问题
扫一扫
842
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
