目录
五种IO
五种IO
IO=等+拷贝数据
什么叫做高效IO？
高效的IO本质：减少单位时间内，“等”的比重！
IO话题：
a.改变等待的方式（为什么）
b.减少等的比重
IO：讨论如何输入输出
阻塞IO: 在内核将数据准备好之前, 系统调用会一直等待. 所有的套接字, 默认都是阻塞方式
非阻塞IO: 如果内核还未将数据准备好, 系统调用仍然会直接返回, 并且返回EWOULDBLOCK错误码.
非阻塞IO往往需要程序员循环的方式反复尝试读写文件描述符, 这个过程称为轮询. 这对CPU来说是较大的浪费, 一般只有特定场景下才使用
信号驱动IO: 内核将数据准备好的时候, 使用SIGIO信号通知应用程序进行IO操作
IO多路转接: 虽然从流程图上看起来和阻塞IO类似. 实际上最核心在于IO多路转接能够同时等待多个文件描述符的就绪状态
异步IO: 由内核在数据拷贝完成时, 通知应用程序(而信号驱动是告诉应用程序何时可以开始拷贝数据).
小结
任何IO过程中, 都包含两个步骤. 第一是等待, 第二是拷贝. 而且在实际的应用场景中, 等待消耗的时间往往都远远高于拷贝的时间. 让IO更高效, 最核心的办法就是让等待的时间尽量少
高级IO相关重要概念
同步通信 vs 异步通信(synchronous communication/ asynchronous communication)
同步和异步关注的是消息通信机制.
所谓同步，就是在发出一个调用时，在没有得到结果之前，该调用就不返回. 但是一旦调用返回，就得到返回值了; 换句话说，就是由调用者主动等待这个调用的结果;
异步则是相反， 调用在发出之后，这个调用就直接返回了，所以没有返回结果; 换句话说，当一个异步过程调用发出后，调用者不会立刻得到结果; 而是在调用发出后， 被调用者通过状态、通知来通知调用者，或通过回调函数处理这个调用.
另外, 我们回忆在讲多进程多线程的时候, 也提到同步和互斥. 这里的同步通信和进程之间的同步是完全不想干的概念.
进程/线程同步也是进程/线程之间直接的制约关系
是为完成某种任务而建立的两个或多个线程，这个线程需要在某些位置上协调他们的工作次序而等待、传递信息所产生的制约关系. 尤其是在访问临界资源的时候
阻塞 vs 非阻塞
阻塞和非阻塞关注的是程序在等待调用结果（消息，返回值）时的状态.
阻塞调用是指调用结果返回之前，当前线程会被挂起. 调用线程只有在得到结果之后才会返回.
非阻塞调用指在不能立刻得到结果之前，该调用不会阻塞当前线程
补充知识：
什么叫做 等事件 就绪？IO事件就绪
读事件就绪
写事件就绪
非阻塞IO
fcntl
一个文件描述符, 默认都是阻塞IO.
函数原型如下.
#include <unistd.h>
#include <fcntl.h>
int fcntl(int fd, int cmd, ... /* arg */ );
传入的cmd的值不同, 后面追加的参数也不相同.
fcntl函数有5种功能:
复制一个现有的描述符（cmd=F_DUPFD） .
获得/设置文件描述符标记(cmd=F_GETFD或F_SETFD).
获得/设置文件状态标记(cmd=F_GETFL或F_SETFL).
获得/设置异步I/O所有权(cmd=F_GETOWN或F_SETOWN).
获得/设置记录锁(cmd=F_GETLK,F_SETLK或F_SETLKW).
第三种功能, 获取/设置文件状态标记, 就可以将一个文件描述符设置为非阻塞
在非阻塞的情况下，我们读取数据，如果数据没有就绪，系统是以出错的形式返回的（不是错误），没有就绪和真正的出错，使用的是同样的方式标识，去和进一步区分呢？ errno
查看所有报错:
vim /usr/include/asm-generic/errno-base.h
I/O多路转接之select
初识select
select定位：只负责等，得到fd就绪，通知上层进行读取或者写入
select没有读取和写入数据的功能。
read，write，recv，send本身也有等待的功能！（只能传入一个fd）
select能够等待多个fd！
系统提供select函数来实现多路复用输入/输出模型.
select系统调用是用来让我们的程序监视多个文件描述符的状态变化的;
程序会停在select这里等待，直到被监视的文件描述符有一个或多个发生了状态改变;
select的核心功能：
读为例：
1.用户告知内核，OS要帮我关心那些fd上的读事件就绪
2.内核告知用户，OS关心的那些fd上的读事件已经就绪
select函数原型
参数解释:
参数nfds是需要监视的最大的文件描述符值+1；
rdset,wrset,exset分别对应于需要检测的可读文件描述符的集合，可写文件描述符的集 合及异常文件描述符的集合;
参数timeout为结构timeval，用来设置select()的等待时间
参数timeout取值:
NULL:阻塞
timeout={0,0};非阻塞
timeout={5,0};五秒超时
1.只要不就绪，我就不返回
2.只要不就绪，立马返回
3.设置好deadline（最晚时间），deadline之内遵守1，deadline之外遵守2；之内到之外这种行为叫做timeout
三者统一，只要就绪，立马返回
struct timeval{
long tv_sec;//秒
long tv_usec;//微秒
};
函数返回值：
执行成功则返回文件描述词状态已改变的个数
如果返回0代表在描述词状态改变前已超过timeout时间，没有返回
当有错误发生时则返回-1，错误原因存于errno，此时参数readfds， writefds, exceptfds和timeout的值变成不可预测。
错误值可能为：
EBADF 文件描述词为无效的或该文件已关闭
EINTR 此调用被信号所中断
EINVAL 参数n 为负值。
ENOMEM 核心内存不足
select执行过程
理解select模型的关键在于理解fd_set,为说明方便，取fd_set长度为1字节， fd_set中的每一bit可以对应一个文件描符fd。则1字节长的fd_set最大可以对应8个fd.
（1）执行fd_set set; FD_ZERO(&set);则set用位表示是0000,0000。
（2）若fd＝ 5,执行FD_SET(fd,&set);后set变为0001,0000(第5位置为1)
（3）若再加入fd＝ 2， fd=1,则set变为0001,0011
（4）执行select(6,&set,0,0,0)阻塞等待
（5）若fd=1,fd=2上都发生可读事件，则select返回，此时set变为0000,0011。注意：没有事件发生的fd=5被清空
select因为使用输入输出型参数标识不同的含义，意味着后面每一次都需要对fd_set进行重新设置！
->你的程序怎么知道，你拥有的fd！用户必须定义数组或者其他容器结构，将历史fd保存
代码基础框架
client向server发送消息的服务
Sock.hpp
#pragma once
#include<iostream>
#include<string>
#include<cstring>
#include<cstdlib>
#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<unistd.h>
using namespace std;
class Sock
{
public:
static int Socket()
{
int sock = socket(AF_INET,SOCK_STREAM,0);
if(sock < 0)
{
cerr<<"socket error"<<endl;
exit(2);
}
return sock;
}
static void Bind(int sock,uint16_t port)
{
struct sockaddr_in local;
memset(&local,0,sizeof(local));
local.sin_family = AF_INET;
local.sin_port = htons(port);
local.sin_addr.s_addr = INADDR_ANY;
if(bind(sock,(struct sockaddr*)&local,sizeof(local))<0)
{
cerr<<"bind error!"<<endl;
exit(3);
}
}
static void Listen(int sock)
{
if(listen(sock,5)<0)
{
cerr<<"listen error!"<<endl;
exit(4);
}
}
static int Accept(int sock)
{
struct sockaddr_in peer;
socklen_t len = sizeof(peer);
int fd = accept(sock,(struct sockaddr*)&peer,&len);
if(fd>0)
{
return fd;
}
else return -1;
}
static void Connect(int sock,std::string ip,uint16_t port)
{
struct sockaddr_in server;
memset(&server,0,sizeof(server));
server.sin_family = AF_INET;
server.sin_port = htons(port);
server.sin_addr.s_addr = inet_addr(ip.c_str());
if(connect(sock,(struct sockaddr*)&server,sizeof(server)) == 0)
{
cout<<"connect success!"<<endl;
}
else{
cout<<"connect failed!"<<endl;
exit(5);
}
}
};
select_server.cc
#include <iostream>
#include <string>
#include <sys/select.h>
#include "Sock.hpp"
#define NUM (sizeof(fd_set)*8)
//内容>=0，合法的fd，如果是-1，该位置没有fd
int fd_array[NUM];
void Usage(std::string proc)
{
std::cout << "Usage" << proc << "port" << std::endl;
}
// ./Select_server 端口号
int main(int argc, char *argv[])
{
if (argc != 2)
{
Usage(argv[0]);
exit(1);
}
u_int16_t port = (u_int16_t)atoi(argv[1]);
int listen_sock = Sock::Socket();
Sock::Bind(listen_sock, port);
Sock::Listen(listen_sock);
memset(fd_array,0,sizeof(fd_array));
// accept本质是通过listen_sock获取新链接
//前提是listen_sock上面有新链接，accept不知道有新链接
// accept阻塞式等待
//站在多路转接的视角，我们认为链接到来，对于listen_sock，就是读事件就绪！
//对于所有的服务器，最开始的时候，只有listen_sock
//事件循环
fd_set rfds;
fd_array[0]=listen_sock;
for (;;)
{
FD_ZERO(&rfds);
int max_fd=fd_array[0];
for(int i = 0;i<NUM;i++)
{
if(fd_array[i]==-1)
continue;
//下面的都是合法的fd
FD_SET(fd_array[i],&rfds);//所有要关心读事件的fd，添加到rfds中
if(max_fd<fd_array[i])
{
max_fd=fd_array[i];//更新最大fd
}
}
struct timeval timeout = {1,0};
//服务器上的所有fd，包括listen_sock,都要交给select检测！
//recv,read,write,send,accept,只负责自己最核心的工作：真正的读写（listen_sock:accept）！
int n = select(max_fd+1,&rfds,nullptr,nullptr,&timeout);//第三个nullptr暂时阻塞方式
switch (n)
{
case -1:
std::cerr << "select 失败！" << std::endl;
break;
case 0:
std::cerr << "select timeout" << std::endl;
break;
default:
std::cout << "有fd对应的事件就绪" << std::endl;
break;
}
}
// std::cout<<sizeof(fd_set)<<std::endl; 128
return 0;
}
输出描述：
timeout = {1,0};
每间隔一秒打印一次
当timeout设为：nullptr
在网页部分输入你的服务器ip+端口号，就会：
timeout = {0,0};
就会无限循环的输出
select timeout
补充完善
select_server.cc
#include <iostream>
#include <string>
#include <sys/select.h>
#include "Sock.hpp"
#define NUM (sizeof(fd_set) * 8)
//内容>=0，合法的fd，如果是-1，该位置没有fd
int fd_array[NUM];
void Usage(std::string proc)
{
std::cout << "Usage" << proc << "port" << std::endl;
}
// ./Select_server 端口号
int main(int argc, char *argv[])
{
if (argc != 2)
{
Usage(argv[0]);
exit(1);
}
u_int16_t port = (u_int16_t)atoi(argv[1]);
int listen_sock = Sock::Socket();
Sock::Bind(listen_sock, port);
Sock::Listen(listen_sock);
memset(fd_array, 0, sizeof(fd_array));//全部初始化为零，即：里面全部被占用
// accept本质是通过listen_sock获取新链接
//前提是listen_sock上面有新链接，accept不知道有新链接
// accept阻塞式等待
//站在多路转接的视角，我们认为链接到来，对于listen_sock，就是读事件就绪！
//对于所有的服务器，最开始的时候，只有listen_sock
//事件循环
fd_set rfds;
fd_array[0] = listen_sock;
for (;;)
{
FD_ZERO(&rfds);
int max_fd = fd_array[0];
for (int i = 0; i < NUM; i++)
{
if (fd_array[i] == -1)
continue;
//下面的都是合法的fd
FD_SET(fd_array[i], &rfds); //所有要关心读事件的fd，添加到rfds中
if (max_fd < fd_array[i])
{
max_fd = fd_array[i]; //更新最大fd
}
}
struct timeval timeout = {1, 0};
//服务器上的所有fd，包括listen_sock,都要交给select检测！
// recv,read,write,send,accept,只负责自己最核心的工作：真正的读写（listen_sock:accept）！
int n = select(max_fd + 1, &rfds, nullptr, nullptr, nullptr); //第三个nullptr暂时阻塞方式
switch (n)
{
case -1:
std::cerr << "select 失败！" << std::endl;
break;
case 0:
std::cerr << "select timeout" << std::endl;
break;
default:
std::cout << "有fd对应的事件就绪" << std::endl;
for (int i = 0; i < NUM; i++)
{
if (fd_array[i] == -1)
continue;
//下面的fd都是合法的fd，合法的fd不一定是就绪的fd
if (FD_ISSET(fd_array[i], &rfds))
{
std::cout << "sock:" << fd_array[i] << "上面有了读事件,可以读取了!" << std::endl;
//一定是读事件就绪了！
//该就绪的fd就在fd_array[i]保存！
// read,recv一定不会被阻塞
//读事件就绪，就一定可以recv，read吗？不一定，
//读时间就绪，listen_sock就绪，也是以读事件就绪返回的
if (fd_array[i] == listen_sock)
{
std::cout << "listen_sock:" << listen_sock << "有了新的链接到来" << std::endl;
// accept
int sock = Sock::Accept(listen_sock);
if (sock >= 0)
{
std::cout << "listen_sock:" << listen_sock << "获取新的链接成功" << std::endl;
//获取成功
//新链接到来，不意味着有数据到来！
// select知道那些fd可以被读取！
//无法将fd设置进select，但是，我们有fd_array[]！
int pos=1;
for (; pos < NUM; pos++)
{
//这个位置没有被使用！
if (fd_array[pos] == -1)
break;
}
// 1.找到一个位置没有被使用
// 2.找完了所有的fd_array[],都没有找到没有被使用的位置
if (pos < NUM) // 1
{
std::cout << "新链接:" << sock << "已经被添加到了数组[" << pos << "]的位置" << std::endl;
fd_array[pos] = sock;
}
else // 2
{
//说明服务器已经满载，无法处理新的请求
std::cout<<"服务器满载,关闭新的链接"<<std::endl;
close(sock);
}
}
}
else
{
// read,recv
}
}
}
break;
}
}
// std::cout<<sizeof(fd_set)<<std::endl; 128
return 0;
}
修改代码：
//memset(fd_array, 0, sizeof(fd_array));//全部初始化为零，即：里面全部被占用
for(int j =0;j<NUM;j++)//全部初始化为-1
{
fd_array[j]=-1;
}
完整代码与测试（select完整框架）
select_server.cc
#include <iostream>
#include <string>
#include <sys/select.h>
#include "Sock.hpp"
#define NUM (sizeof(fd_set) * 8)
//内容>=0，合法的fd，如果是-1，该位置没有fd
int fd_array[NUM];
void Usage(std::string proc)
{
std::cout << "Usage" << proc << "port" << std::endl;
}
// ./Select_server 端口号
int main(int argc, char *argv[])
{
if (argc != 2)
{
Usage(argv[0]);
exit(1);
}
u_int16_t port = (u_int16_t)atoi(argv[1]);
int listen_sock = Sock::Socket();
Sock::Bind(listen_sock, port);
Sock::Listen(listen_sock);
//memset(fd_array, 0, sizeof(fd_array));//全部初始化为零，即：里面全部被占用
for(int j =0;j<NUM;j++)//全部初始化为-1
{
fd_array[j]=-1;
}
// accept本质是通过listen_sock获取新链接
//前提是listen_sock上面有新链接，accept不知道有新链接
// accept阻塞式等待
//站在多路转接的视角，我们认为链接到来，对于listen_sock，就是读事件就绪！
//对于所有的服务器，最开始的时候，只有listen_sock
//事件循环
fd_set rfds;
fd_array[0] = listen_sock;
for (;;)
{
FD_ZERO(&rfds);
int max_fd = fd_array[0];
for (int i = 0; i < NUM; i++)
{
if (fd_array[i] == -1)
continue;
//下面的都是合法的fd
FD_SET(fd_array[i], &rfds); //所有要关心读事件的fd，添加到rfds中
if (max_fd < fd_array[i])
{
max_fd = fd_array[i]; //更新最大fd
}
}
struct timeval timeout = {1, 0};
//服务器上的所有fd，包括listen_sock,都要交给select检测！
// recv,read,write,send,accept,只负责自己最核心的工作：真正的读写（listen_sock:accept）！
int n = select(max_fd + 1, &rfds, nullptr, nullptr, nullptr); //第三个nullptr暂时阻塞方式
switch (n)
{
case -1:
std::cerr << "select 失败！" << std::endl;
break;
case 0:
std::cerr << "select timeout" << std::endl;
break;
default:
std::cout << "有fd对应的事件就绪" << std::endl;
for (int i = 0; i < NUM; i++)
{
if (fd_array[i] == -1)
continue;
//下面的fd都是合法的fd，合法的fd不一定是就绪的fd
if (FD_ISSET(fd_array[i], &rfds))
{
std::cout << "sock:" << fd_array[i] << "上面有了读事件,可以读取了!" << std::endl;
//一定是读事件就绪了！
//该就绪的fd就在fd_array[i]保存！
// read,recv一定不会被阻塞
//读事件就绪，就一定可以recv，read吗？不一定，
//读时间就绪，listen_sock就绪，也是以读事件就绪返回的
if (fd_array[i] == listen_sock)
{
std::cout << "listen_sock:" << listen_sock << "有了新的链接到来" << std::endl;
// accept
int sock = Sock::Accept(listen_sock);
if (sock >= 0)
{
std::cout << "listen_sock:" << listen_sock << "获取新的链接成功" << std::endl;
//获取成功
//新链接到来，不意味着有数据到来！
// select知道那些fd可以被读取！
//无法将fd设置进select，但是，我们有fd_array[]！
int pos=1;
for (; pos < NUM; pos++)
{
//这个位置没有被使用！
if (fd_array[pos] == -1)
break;
}
// 1.找到一个位置没有被使用
// 2.找完了所有的fd_array[],都没有找到没有被使用的位置
if (pos < NUM) // 1
{
std::cout << "新链接:" << sock << "已经被添加到了数组[" << pos << "]的位置" << std::endl;
fd_array[pos] = sock;
}
else // 2
{
//说明服务器已经满载，无法处理新的请求
std::cout<<"服务器满载,关闭新的链接"<<std::endl;
close(sock);
}
}
}
else
{
//普通的sock事件就绪！可以进行读取recv，read。
//本次读取不一定能读完，读完，也不一定没有所谓的数据包粘包问题
std::cout<<"sock:"<<fd_array[i]<<"上面有普通读取"<<std::endl;
char recv_buffer[1024]={0};
ssize_t s=recv(fd_array[i],recv_buffer,sizeof(recv_buffer)-1,0);
if(s>0)
{
recv_buffer[s]=0;
std::cout<<"client["<< fd_array[i]<<"]#"<<recv_buffer<<std::endl;
}
else if(s==0)//网络读取时，0代表对端链接关闭
{
std::cout<<"sock:"<<fd_array[i]<<"关闭了链接，客户端退出了！"<<std::endl;
//四次挥手，对方关闭了，我们也要关闭
close(fd_array[i]);
//从数组中将这个文件描述符去掉
fd_array[i]=-1;
std::cout<<"已经在数组中fd_array["<<i<<"]中去掉了sock:"<<fd_array[i]<<std::endl;
}
else{
//读取失败
close(fd_array[i]);
fd_array[i]=-1;
std::cout<<"已经在数组中fd_array["<<i<<"]中去掉了sock:"<<fd_array[i]<<std::endl;
}
}
}
}
break;
}
}
// std::cout<<sizeof(fd_set)<<std::endl; 128
return 0;
}
延伸补充：
客户端如何关闭链接？
ctrl+】
quit
总结
优点：
可以一次等待多个fd，可以让等待的时间重叠，在一定程度可以提高IO的效率。
缺点：
1.每次都要重新设置，每次完成之后，需要遍历检测
2.fd_set，它能够让select同时检测的fd，是有上限的
3.select底层需要轮询式的检测那些fd上的那些时间就绪了
4.频繁就绪，会发生频繁拷贝，即：select可能会较为高频的进行用户到内核，内核到用户的频繁拷贝问题
socket就绪条件
读就绪
socket内核中, 接收缓冲区中的字节数, 大于等于低水位标记SO_RCVLOWAT. 此时可以无阻塞的读该文件描述符, 并且返回值大于0;
socket TCP通信中, 对端关闭连接, 此时对该socket读, 则返回0;
监听的socket上有新的连接请求;
socket上有未处理的错误
写就绪
socket内核中, 发送缓冲区中的可用字节数(发送缓冲区的空闲位置大小), 大于等于低水位标记SO_SNDLOWAT, 此时可以无阻塞的写, 并且返回值大于0;
socket的写操作被关闭(close或者shutdown). 对一个写操作被关闭的socket进行写操作, 会触发SIGPIPE信号;
socket使用非阻塞connect连接成功或失败之后;
socket上有未读取的错误
异常就绪
socket上收到带外数据. 关于带外数据, 和TCP紧急模式相关(回忆TCP协议头中, 有一个紧急指针的字段)
I/O多路转接之poll [选学]
poll函数接口
参数说明
fds是一个poll函数监听的结构列表. 每一个元素中, 包含了三部分内容: 文件描述符, 监听的事件集合, 返回的事件集合.
nfds表示fds数组的长度.
timeout表示poll函数的超时时间, 单位是毫秒(ms).
0：永远等待
timeout大于0：timeout以内阻塞等待，timeout以外的返回一次
-1：永久阻塞
events和revents的取值:
返回结果
返回值小于0, 表示出错;
返回值等于0, 表示poll函数等待超时;
返回值大于0, 表示poll由于监听的文件描述符就绪而返回
poll测试代码：
#include <iostream>
#include <poll.h>
#include <unistd.h>
int main()
{
struct pollfd rfds;
rfds.fd = 0;
rfds.events = POLLIN;
rfds.revents = 0;
while (true)
{
int n = poll(&rfds, 1, 1000);
switch (n)
{
case 0:
std::cout << "time out..." << std::endl;
break;
case -1:
std::cerr << "poll error!" << std::endl;
break;
default:
std::cout << "有事件发生！" << std::endl;
if (rfds.revents & POLLIN)
{
char buffer[128];
std::cout << rfds.fd << "上面的读时间发生了！" << std::endl;
ssize_t s = read(0, buffer, sizeof(buffer) - 1);
if (s > 0)
{
std::cout << rfds.fd << "说:" << buffer << std::endl;
}
}
break;
}
}
return 0;
}
poll总结
优点：
不同与select使用三个位图来表示三个fdset的方式， poll使用一个pollfd的指针实现.
pollfd结构包含了要监视的event和发生的event，不再使用select“参数-值”传递的方式. 接口使用比select更方便
poll并没有最大数量限制 (但是数量过大后性能也是会下降)
poll解决了select因为位图，而导致检测的文件描述符有上限的问题
缺点：
poll中监听的文件描述符数目增多时
和select函数一样， poll返回后，需要轮询pollfd来获取就绪的描述符.
每次调用poll都需要把大量的pollfd结构从用户态拷贝到内核中.
同时连接的大量客户端在一时刻可能只有很少的处于就绪状态, 因此随着监视的描述符数量的增长, 其效率也会线性下降
I/O多路转接之epoll
epoll初识
按照man手册的说法: 是为处理大批量句柄而作了改进的poll.
它是在2.5.44内核中被引进的(epoll(4) is a new API introduced in Linux kernel 2.5.44)
它几乎具备了之前所说的一切优点，被公认为Linux2.6下性能最好的多路I/O就绪通知方法.
epoll是干什么的？
等，等是手段，通过用户设置的某些fd及其事件，告知内核，让内核用户关心，一旦就绪，通知上层
epoll的相关系统调用
epoll接口测试
最基础框架
#include <iostream>
#include <unistd.h>
#include <sys/epoll.h>
#include <cstdlib>
#include <string>
#include "Sock.hpp"
#define SIZE 128
#define NUM 64
void Usage(std::string proc)
{
std::cerr << "Usage:" << proc << "port" << std::endl;
}
// ./Epoll_server port
int main(int argc, char *argv[])
{
if (argc != 2)
{
Usage(argv[0]);
exit(1);
}
// 1.建立tcp监听socket
u_int16_t port = (u_int16_t)atoi(argv[1]);
int listen_sock = Sock::Socket();
Sock::Bind(listen_sock, port);
Sock::Listen(listen_sock);
// 2.创建epoll模型，获得epfd（文件描述符）
int epfd = epoll_create(SIZE);
std::cout << "fd:" << epfd << std::endl; // 3
// 3.将listen_sock及其他所关心的事件添加到内核
struct epoll_event ev;
ev.events = EPOLLIN;
// ev.data
epoll_ctl(epfd, EPOLL_CTL_ADD, listen_sock, &ev);
// 4.事件循环
volatile bool quit = false;
struct epoll_event revs[NUM];
while (!quit)
{
int timeout = 1000;
//这里传入的数组，仅仅是尝试从内核中拿回来已经就绪的事件
int n = epoll_wait(epfd, revs, NUM, timeout); // n:就绪事件个数，所有就绪事件按照下标有序放进revs中
switch (n)
{
case 0:
std::cout << "time out..." << std::endl;
break;
case -1:
std::cerr << "epoll error..." << std::endl;
break;
default:
std::cout<<"有事件就绪!"<<std::endl;
break;
}
}
close(epfd);
close(listen_sock);
return 0;
}
测试结果和poll select基础框架测试用例类似
epoll原理
创建epoll模型，需要创建：红黑树，就绪队列，回调机制
epoll基础框架
#include <iostream>
#include <unistd.h>
#include <sys/epoll.h>
#include <cstdlib>
#include <string>
#include "Sock.hpp"
#define SIZE 128
#define NUM 64
void Usage(std::string proc)
{
std::cerr << "Usage:" << proc << "port" << std::endl;
}
// ./Epoll_server port
int main(int argc, char *argv[])
{
if (argc != 2)
{
Usage(argv[0]);
exit(1);
}
// 1.建立tcp监听socket
u_int16_t port = (u_int16_t)atoi(argv[1]);
int listen_sock = Sock::Socket();
Sock::Bind(listen_sock, port);
Sock::Listen(listen_sock);
// 2.创建epoll模型，获得epfd（文件描述符）
int epfd = epoll_create(SIZE);
// std::cout << "fd:" << epfd << std::endl; // 3
// 3.将listen_sock及其他所关心的事件添加到内核
struct epoll_event ev;
ev.events = EPOLLIN;
ev.data.fd = listen_sock;
epoll_ctl(epfd, EPOLL_CTL_ADD, listen_sock, &ev);
// 4.事件循环
volatile bool quit = false;
struct epoll_event revs[NUM];
while (!quit)
{
int timeout = -1;
//这里传入的数组，仅仅是尝试从内核中拿回来已经就绪的事件
int n = epoll_wait(epfd, revs, NUM, timeout); // n:就绪事件个数，所有就绪事件按照下标有序放进revs中
switch (n)
{
case 0:
std::cout << "time out..." << std::endl;
break;
case -1:
std::cerr << "epoll error..." << std::endl;
break;
default:
std::cout << "有事件就绪!" << std::endl;
// 5.处理就绪事件
for (int i = 0; i < n; i++)
{
int sock = revs[i].data.fd;
std::cout << "文件描述符：" << sock << "上面有事件就绪" << std::endl;
if (revs[i].events & EPOLLIN)
{
std::cout << "文件描述符：" << sock << "读事件就绪" << std::endl;
if (sock == listen_sock)
{
// 5.1处理链接事件
std::cout << "文件描述符：" << sock << "链接数据就绪" << std::endl;
int fd = Sock::Accept(listen_sock);
if (fd >= 0)
{
std::cout << "获取新链接" << fd << "成功！" << std::endl;
//不能立即读取！
struct epoll_event _ev;
_ev.events = EPOLLIN; //关心读和写EPOLLIN | EPOLLOUT
_ev.data.fd = fd;
epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &_ev); //新的fd托管给了epoll
std::cout << "已经将" << fd << "托管给epoll了!" << std::endl;
std::cout << "-----分隔符-----" << std::endl;
}
else
{
// do nothing!
}
}
else
{
// 5.2正常读取处理
std::cout << "文件描述符：" << sock << "正常数据就绪" << std::endl;
char buffer[1024];
ssize_t s = recv(sock, buffer, sizeof(buffer) - 1, 0);
if (s > 0)
{
buffer[s] = 0;
std::cout << "client[" << sock << "]:" << buffer << std::endl;
}
else if (s == 0)
{
//对端关闭链接
std::cout << "client quit:" << sock << std::endl;
close(sock);
epoll_ctl(epfd, EPOLL_CTL_DEL, sock, nullptr); //删除事件
std::cout << "sock:" << sock << "删除成功！" << std::endl;
}
else
{
//读取失败
std::cout << "读取失败：" << sock << std::endl;
close(sock);
epoll_ctl(epfd, EPOLL_CTL_DEL, sock, nullptr); //删除事件
std::cout << "sock:" << sock << "删除成功！" << std::endl;
}
std::cout << "-----分隔符-----" << std::endl;
}
}
else if (revs[i].events & EPOLLOUT)
{
// 5.3处理写事件
}
else
{
}
}
break;
}
}
close(epfd);
close(listen_sock);
return 0;
}
epoll工作方式
epoll有2种工作方式-水平触发(LT)和边缘触发(ET)
**LT:**当内核区有你的数据，就会一直通知你。
**ET:**当内核区有你的数据，这些数据从无到有，从有到多，就会只给你发送一次信息。
优势：通过它的这种通知策略，倒逼程序员一旦开始读取数据，就要一直读完；
两种通知方式，他们的通知次数是相同的，ET的通知面更多;
select,poll,epoll默认通知方式：LT
ET-》通知一次-》recv/accept/read-》准备读取-》如何保证将本次全部读取完毕-》循环读取-》可能会在读取的最后一次卡住（阻塞）-.》单进程-》解决？-》ET模式下的所有fd，将其设置为非阻塞！
epoll版本计算器
1.我们需要给每一个fd，都要有自己专属的输入输出缓冲区！
2.虽然已经对等和拷贝在接口层面已经进行了分离，但是在代码逻辑上依旧是耦合在一起的（通过回调的方式进行解耦）
3.epoll最大的优势在于 就绪事件通知机制！
详细代码
Accepter.hpp
#pragma once
#include "Reactor.hpp"
#include"Sock.hpp"
#include"Service.hpp"
#include"Util.hpp"
int Accepter(Event* evp)
{
std::cout<<"有新的链接到来了，就绪的sock是："<<evp->sock<<std::endl;
while(true)
{
int sock=Sock::Accept(evp->sock);
if(sock<0){
std::cout<<"已经将所有的链接读完"<<std::endl;
break;
}
SetNonBlock(sock);//设为非阻塞
std::cout<<"获取成功"<<sock<<std::endl;
//获取链接成功
Event *other_ev= new Event();
other_ev->sock=sock;
other_ev->R=evp->R;
//为什么要让所有的Event指向自己所属的Reactor？
//recver,sender,errorer就是我们代码中的较顶层，只负责真正的读取！
other_ev->RegisterCallBack(Recver,Sender,Errorer);
evp->R->InsertEvent(other_ev,EPOLLIN|EPOLLET);
}
}
epoll_server.cc
#include"Reactor.hpp"
#include"Sock.hpp"
#include"Accepter.hpp"
#include"Util.hpp"
static void Usage(std::string proc)
{
std::cerr<<"Usage:"<<proc<<"proc"<<std::endl;
}
int main(int agrc,char *argv[])
{
if(agrc!=2)
{
Usage(argv[0]);
exit(1);
}
//1.创建socket，监听
int listen_sock=Sock::Socket();
SetNonBlock(listen_sock);//设为非阻塞
Sock::Bind(listen_sock,(uint16_t)atoi(argv[1]));
Sock::Listen(listen_sock);
//2.创建Reactor对象
// Reactor 反应堆模式：通过多路转接方案，被动的采用事件派发的方式，去反向的调用对应的回调函数
// a.检测到事件--epoll
// b.派发事件---Dispatcher(事件派发+IO)+业务处理 ：半同步半异步的处理方式
// c.链接--- accept
// d.IO---recver,sender
Reactor *R=new Reactor();
R->InitReactor();
//3.给Reactor反应堆中加柴火
//3.1有柴火
Event *evp=new Event;
evp->sock=listen_sock;
evp->R=R;
//Accepter:链接管理器
evp->RegisterCallBack(Accepter,nullptr,nullptr);
//3.2将准好的柴火放进反应堆Reactor中
R->InsertEvent(evp,EPOLLIN | EPOLLET);
//4.开始进行事件派发
int timeout =1000;
for(;;)
{
R->Dispatcher(timeout);
}
return 0;
}
Makefile
Epoll_server:epoll_server.cc
g++ -o $@ $^
.PHONY:clean
clean:
rm -rf Epoll_server
Reactor.hpp
#pragma once
#include <iostream>
#include <string>
#include <vector>
#include <unordered_map>
#include <cstdlib>
#include <sys/epoll.h>
#include <unistd.h>
// 一般处理IO的时候，我们只有三种接口需要处理
// 处理读取
// 处理写入
// 处理异常
#define SIZE 128
#define NUM 64
class Event;
class Reactor;
typedef int (*callback_t)(Event *ev); //函数指针
//需要epoll管理的基本节点
class Event
{
public:
//对应的文件描述符
int sock;
//对应的sock，对应的输入输出缓冲区
std::string inbuffer;
//对应的sock，对应的输出缓冲区
std::string outbuffer;
// sock设置回调
callback_t recver;
callback_t sender;
callback_t errorer;
//试着Event回指Reactor的指针
Reactor *R;
public:
Event()
{
sock = -1;
recver = nullptr;
sender = nullptr;
errorer = nullptr;
R = nullptr;
}
//设置回调
void RegisterCallBack(callback_t _recver, callback_t _sender, callback_t _errorer)
{
recver = _recver;
sender = _sender;
errorer = _errorer;
}
~Event() {}
};
//不需要关心任何sock的类型（listen,读,写）
//如何进行使用该类，对Event进行管理
// Reactor:Event=1:n
class Reactor //反应堆模式
{
private:
int epfd;
std::unordered_map<int, Event *> events; // Epoll类管理的所有的Event的集合
public:
Reactor() : epfd(-1) {}
void InitReactor()
{
epfd = epoll_create(SIZE);
if (epfd < 0)
{
std::cerr << "epoll_create error!" << std::endl;
exit(2);
}
std::cout << "InitReactor Success!" << std::endl;
}
bool InsertEvent(Event *evp, uint32_t evs)
{
// 1.将evp中的sock插入到epoll中
struct epoll_event ev;
ev.events = evs;
ev.data.fd = evp->sock;
if (epoll_ctl(epfd, EPOLL_CTL_ADD, evp->sock, &ev) < 0)
{
std::cerr << "EPOLL_CTL_ADD event failed!" << std::endl;
return false;
}
// 2.将ev本身插入到unordered_map中
events.insert({evp->sock, evp});
}
void DeleteEvent(Event *evp)
{
int sock = evp->sock;
auto iter = events.find(sock);
if (iter != events.end())
{
//将evp中的sock从epoll中删除
epoll_ctl(epfd, EPOLL_CTL_DEL, sock, nullptr);
events.erase(iter);
close(sock);
//删除event节点
delete evp;
}
}
//使能读写
bool EnableRW(int sock, bool enread, bool enwrite)
{
struct epoll_event ev;
ev.events = EPOLLET | (enread ? EPOLLIN : 0) | (enwrite ? EPOLLOUT : 0);
ev.data.fd = sock;
if (epoll_ctl(epfd, EPOLL_CTL_MOD, sock, &ev) < 0)
{
std::cerr << "修改失败" << std::endl;
return false;
}
return true;
}
//判断当前的sock是否合法
bool IsSockOK(int sock)
{
auto iter=events.find(sock);
return iter==events.end()?false:true;
}
//就绪事件派发器
void Dispatcher(int timeout)
{
struct epoll_event revs[NUM];
int n = epoll_wait(epfd, revs, NUM, timeout);
for (int i = 0; i < n; i++)
{
int sock = revs[i].data.fd;
uint32_t revents = revs[i].events;
//代表差错处理，将所有的错误问题全部转化成为让IO函数去解决
if (revents & EPOLLERR)
revents |= (EPOLLIN | EPOLLOUT);
if (revents & EPOLLHUP)
revents |= (EPOLLIN | EPOLLOUT);
//读数据就绪
if (revents & EPOLLIN)
{
//直接调用回调方法，执行对应的读取
if (IsSockOK(sock) &&events[sock]->recver)
events[sock]->recver(events[sock]);
}
//写数据就绪
if (revents & EPOLLOUT)
{
if (IsSockOK(sock) && events[sock]->sender)
events[sock]->sender(events[sock]);
}
}
}
~Reactor() {}
};
Service.hpp
#pragma once
#include <iostream>
#include <string>
#include <vector>
#include <unordered_map>
#include <cstdlib>
#include <sys/epoll.h>
#include <unistd.h>
// 一般处理IO的时候，我们只有三种接口需要处理
// 处理读取
// 处理写入
// 处理异常
#define SIZE 128
#define NUM 64
class Event;
class Reactor;
typedef int (*callback_t)(Event *ev); //函数指针
//需要epoll管理的基本节点
class Event
{
public:
//对应的文件描述符
int sock;
//对应的sock，对应的输入输出缓冲区
std::string inbuffer;
//对应的sock，对应的输出缓冲区
std::string outbuffer;
// sock设置回调
callback_t recver;
callback_t sender;
callback_t errorer;
//试着Event回指Reactor的指针
Reactor *R;
public:
Event()
{
sock = -1;
recver = nullptr;
sender = nullptr;
errorer = nullptr;
R = nullptr;
}
//设置回调
void RegisterCallBack(callback_t _recver, callback_t _sender, callback_t _errorer)
{
recver = _recver;
sender = _sender;
errorer = _errorer;
}
~Event() {}
};
//不需要关心任何sock的类型（listen,读,写）
//如何进行使用该类，对Event进行管理
// Reactor:Event=1:n
class Reactor //反应堆模式
{
private:
int epfd;
std::unordered_map<int, Event *> events; // Epoll类管理的所有的Event的集合
public:
Reactor() : epfd(-1) {}
void InitReactor()
{
epfd = epoll_create(SIZE);
if (epfd < 0)
{
std::cerr << "epoll_create error!" << std::endl;
exit(2);
}
std::cout << "InitReactor Success!" << std::endl;
}
bool InsertEvent(Event *evp, uint32_t evs)
{
// 1.将evp中的sock插入到epoll中
struct epoll_event ev;
ev.events = evs;
ev.data.fd = evp->sock;
if (epoll_ctl(epfd, EPOLL_CTL_ADD, evp->sock, &ev) < 0)
{
std::cerr << "EPOLL_CTL_ADD event failed!" << std::endl;
return false;
}
// 2.将ev本身插入到unordered_map中
events.insert({evp->sock, evp});
}
void DeleteEvent(Event *evp)
{
int sock = evp->sock;
auto iter = events.find(sock);
if (iter != events.end())
{
//将evp中的sock从epoll中删除
epoll_ctl(epfd, EPOLL_CTL_DEL, sock, nullptr);
events.erase(iter);
close(sock);
//删除event节点
delete evp;
}
}
//使能读写
bool EnableRW(int sock, bool enread, bool enwrite)
{
struct epoll_event ev;
ev.events = EPOLLET | (enread ? EPOLLIN : 0) | (enwrite ? EPOLLOUT : 0);
ev.data.fd = sock;
if (epoll_ctl(epfd, EPOLL_CTL_MOD, sock, &ev) < 0)
{
std::cerr << "修改失败" << std::endl;
return false;
}
return true;
}
//判断当前的sock是否合法
bool IsSockOK(int sock)
{
auto iter=events.find(sock);
return iter==events.end()?false:true;
}
//就绪事件派发器
void Dispatcher(int timeout)
{
struct epoll_event revs[NUM];
int n = epoll_wait(epfd, revs, NUM, timeout);
for (int i = 0; i < n; i++)
{
int sock = revs[i].data.fd;
uint32_t revents = revs[i].events;
//代表差错处理，将所有的错误问题全部转化成为让IO函数去解决
if (revents & EPOLLERR)
revents |= (EPOLLIN | EPOLLOUT);
if (revents & EPOLLHUP)
revents |= (EPOLLIN | EPOLLOUT);
//读数据就绪
if (revents & EPOLLIN)
{
//直接调用回调方法，执行对应的读取
if (IsSockOK(sock) &&events[sock]->recver)
events[sock]->recver(events[sock]);
}
//写数据就绪
if (revents & EPOLLOUT)
{
if (IsSockOK(sock) && events[sock]->sender)
events[sock]->sender(events[sock]);
}
}
}
~Reactor() {}
};
Sock.hpp
#pragma once
#include<iostream>
#include<string>
#include<cstring>
#include<cstdlib>
#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<unistd.h>
using namespace std;
class Sock
{
public:
static int Socket()
{
int sock = socket(AF_INET,SOCK_STREAM,0);
if(sock < 0)
{
cerr<<"socket error"<<endl;
exit(2);
}
return sock;
}
static void Bind(int sock,uint16_t port)
{
struct sockaddr_in local;
memset(&local,0,sizeof(local));
local.sin_family = AF_INET;
local.sin_port = htons(port);
local.sin_addr.s_addr = INADDR_ANY;
if(bind(sock,(struct sockaddr*)&local,sizeof(local))<0)
{
cerr<<"bind error!"<<endl;
exit(3);
}
}
static void Listen(int sock)
{
if(listen(sock,5)<0)
{
cerr<<"listen error!"<<endl;
exit(4);
}
}
static int Accept(int sock)
{
struct sockaddr_in peer;
socklen_t len = sizeof(peer);
int fd = accept(sock,(struct sockaddr*)&peer,&len);
if(fd>0)
{
return fd;
}
else return -1;
}
static void Connect(int sock,std::string ip,uint16_t port)
{
struct sockaddr_in server;
memset(&server,0,sizeof(server));
server.sin_family = AF_INET;
server.sin_port = htons(port);
server.sin_addr.s_addr = inet_addr(ip.c_str());
if(connect(sock,(struct sockaddr*)&server,sizeof(server)) == 0)
{
cout<<"connect success!"<<endl;
}
else{
cout<<"connect failed!"<<endl;
exit(5);
}
}
};
Util.hpp
#pragma once
#include<iostream>
#include<unistd.h>
#include<fcntl.h>
#include<string>
#include<fcntl.h>
//工具类
//设置一个sock成为非阻塞
void SetNonBlock(int sock)
{
int fl=fcntl(sock,F_GETFL);
if(fl<0)
{
std::cerr<<"fcntl failed!"<<std::endl;
return;
}
fcntl(sock,F_SETFL,fl|O_NONBLOCK);
}
void SplitSegment(std::string &inbuffer,std::vector<std::string> *tokens,std::string sep)
{
while(true)
{
std::cout<<"inbuffer:"<<inbuffer<<std::endl;
auto pos=inbuffer.find(sep);
if(pos==std::string::npos)//报文不完整
{
break;
}
std::string sub=inbuffer.substr(0,pos);
tokens->push_back(sub);
inbuffer.erase(0,pos+sep.size());
}
}
bool Deserialize(const std::string seg,std::string *out1,std::string *out2) //就是和业务强相关
{
std::string op="+";
auto pos=seg.find("+");
if(pos==std::string::npos) return false;
*out1=seg.substr(0,pos);
*out2=seg.substr(pos+op.size());
return true;
}
测试结果
3907
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
