文章目录
- [0. 前言](#0. 前言)
- [1. 五种IO模型](#1. 五种IO模型)
- [2. 非阻塞IO](#2. 非阻塞IO)
- [3. select](#3. select)
0. 前言
在应用层用户调用read或者write方法读写的时候，本质上是是拷贝函数。
例如调用
read的时候，如果底层接收缓冲区没有数据，那么就会阻塞式的等待；调用write时，如果发送缓冲区是满的，此时上层也无法将数据拷贝给下层，也会阻塞式等待。
所以IO = 等待 + 拷贝，要进行拷贝，就先要判断读写事件是否就绪。
判断IO是否高效，就是看单位时间内，等的比重占比越小，IO效率越高。
1. 五种IO模型
大三
-
阻塞IO
钓鱼佬A：拿着鱼竿钓鱼，在钓鱼的时候，什么也不干，就盯着鱼漂，鱼咬钩就拉杆，不咬钩就一直盯着
-
非阻塞IO（非阻塞轮询）
钓鱼佬B：拿着鱼竿钓鱼，钓鱼的时候，玩一会手机，看一下鱼漂；吃一点东西，看一下鱼漂
-
信号驱动IO
钓鱼佬C：在鱼竿顶部放了一个铃铛，然后开始钓鱼，期间一直干自己的事情，当听见铃铛响的时候，才拉鱼竿
-
多路复用IO
钓鱼佬D：这是一个充值玩家，一次性放很多很多鱼竿，来回走路检测这些鱼竿是否钓到鱼
-
异步IO
钓启强：启强不爱钓鱼，但是喜欢吃鱼，找到老墨，让老墨去钓鱼，跟老墨说："你去帮我钓鱼吧，钓到鱼跟我打电话，我去公司办点事"
启强不是执行钓鱼的人，而是钓鱼的发起者，真正执行的老墨
前四种IO都是同步IO
阻塞和非阻塞的区别：
IO = 等 + 拷贝，在本质上，它们等待的时间都一样，说非阻塞效率高，本质上其实是在等待期间，能进行别的操作同步和异步的区别：
凡是参与了IO（参与等或者拷贝），都属于同步IO；
异步IO只是IO的发起者，并不参与IO的过程。
2. 非阻塞IO
将文件描述符设置为非阻塞，可以采用fcntl接口
cpp
#include <unistd.h>
#include <fcntl.h>
int fcntl(int fd, int cmd, ... /* arg */ );一下采用F_GETFD，先获取文件描述符的标记，然后再添加非阻塞选项
cpp
#include<iostream>
#include<unistd.h>
#include<fcntl.h>
#include<cstdio>
#include<cstring>
#include<cerrno>
using namespace std;
void SetNOBlock(int fd)
{
int fl = fcntl(fd, F_GETFD); //获取文件描述符标记
if(fl < 0) //获取失败
{
perror("fcntl");
return;
}
fcntl(fd, F_SETFL, fl | O_NONBLOCK); //添加非阻塞选项
cout << "set " << fd << " non block success" << endl;
}
int main()
{
char buffer[1024];
SetNOBlock(0);
sleep(1);
while(true)
{
// printf("Please Enter: ");
// fflush(stdout);
ssize_t n = read(0, buffer, sizeof(buffer)-1);
if(n > 0)
{
buffer[n-1] = 0;
cout << "echo: " << buffer << endl;
}
else if(n == 0)
{
cout << "read done" << endl;
break;
}
else
{
if(errno == EWOULDBLOCK)
{
cout << "0 fd data not ready, please try again" << endl;
sleep(1);
}
else
{
cerr << "read error, fd = " << n << ", erron code: " << errno << " error str:" << strerror(errno) << endl;
break;
}
}
}
return 0;
}当
read的错误码为11(EWOULDBLOCK)时，表示当前文件描述符数据没有就绪
3. select
select只负责IO当中的等待，它可以等待多个文件描述
cpp
#include <sys/select.h>
int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
void FD_CLR(int fd, fd_set *set);
int FD_ISSET(int fd, fd_set *set);
void FD_SET(int fd, fd_set *set);
void FD_ZERO(fd_set *set);-
int nfds：等待多个文件描述符当中值最大的+1，即maxfd+1 -
fd_set *readfds：输入输出型参数，fd_set是内核提供的一种数据类型，是位图，readfds表示关心读事件比如说要关心0、1、2、3文件描述符的读事件，将位图设置为
0000 1111这是输入的时候当其中某个文件描述符已经就绪。假设3号文件描述符就绪，则返回
0000 1000 -
fd_set *writefds：关心写事件 -
fd_set *exceptfds：关心异常事件 -
struct timeval *timeout：输入输出型参数，时间结构体，设置等待时长cppstruct timeval { time_t tv_sec; //时间戳，以秒为单位 suseconds_t tv_usec; //微秒 };例如
struct timeval timeout = [5,0]，表示每隔5秒timeout一次，如果2秒之后有文件描述符就绪，返回[3,0]；struct timeval timeout = [0,0]，直接返回（非阻塞），也可也设置为null，表示阻塞等待 -
返回值：
> 0：有n个fd已经就绪
== 0：等待超时，没有错误，没有文件描述符就绪
< 0：等待出错
select_server
cpp
#pragma once
#include<iostream>
#include<string>
#include<sys/time.h>
#include"Socket.hpp"
#include"Log.hpp"
static const int defaultport = 8089;
static const int fd_max = sizeof(fd_set) * 8;
const int defaultfd = -1;
class SelectServer
{
public:
SelectServer(uint16_t port = defaultport)
:_port(port)
{
for(int i = 0; i < fd_max; i++)
_rfd_array[i] = defaultfd;
}
bool Init()
{
_listensock.Socket();
_listensock.Bind(_port);
_listensock.Listen();
return true;
}
void Accepter()
{
std::string clientip;
uint16_t clientport;
int sock = _listensock.Accept(&clientip, &clientport); // 此时并不会阻塞, 因为已经上层通知事件已经就绪
if (sock < 0)
return;
log(Info, "accept success, %s:%d, sockfd:%d", clientip.c_str(), clientport, sock);
// 添加到辅助数组
int pos = 1;
for (; pos < fd_max; pos++)
{
if (_rfd_array[pos] != defaultfd)
continue;
else
break;
}
if (pos == fd_max) // 文件描述符满了(位图满了)
{
log(Warning, "server is full, close %d", sock);
close(sock);
}
else
{
_rfd_array[pos] = sock; // 套接字添加到辅助数组
PrintFd(); // Debug
}
}
void Recver(int fd, int pos)
{
// 读事件就绪
char buffer[1024];
ssize_t n = read(fd, buffer, sizeof(buffer) - 1);
if (n > 0)
{
buffer[n] = 0;
std::cout << "get a message: " << buffer << std::endl;
}
else if (n == 0)
{
log(Info, "client quit, me too, close fd:%d", fd);
close(fd);
_rfd_array[pos] = defaultfd; // 从select中移除
}
else
{
log(Warning, " read error, close fd:%d", fd);
close(fd);
_rfd_array[pos] = defaultfd;
}
}
void Dispatcher(const fd_set &rfds)
{
for (int i = 0; i < fd_max; i++)
{
int fd = _rfd_array[i];
if(fd == defaultfd) continue;
if (FD_ISSET(fd, &rfds))
{
if(fd == _listensock.Getfd()) //是监听套接字且已经就绪 获取新链接
{
Accepter();
}
else
{
Recver(fd, i);
}
//其他的事件...
}
}
}
void Start()
{
int listensock = _listensock.Getfd();
_rfd_array[0] = listensock;
for( ; ; )
{
fd_set rfds; //读事件文件描述符
FD_ZERO(&rfds); //位图清零
int maxfd = _rfd_array[0];
for(int i = 0; i < fd_max; i++) //每次都重新设定
{
if(_rfd_array[i] == defaultfd) continue;
FD_SET(_rfd_array[i], &rfds); //该文件描述符设置进位图
if(maxfd < _rfd_array[i])
{
maxfd = _rfd_array[i];
log(Info, "maxfd update, maxfd: %d", maxfd);
}
}
//不可直接accept, accept本质是检测并获取listensock上面的事件
struct timeval timeout = {2, 0}; //输入输出型参数, 需要周期性重复设置
//int s = select(maxfd + 1, &rfds, nullptr, nullptr, &timeout);
int s = select(maxfd + 1, &rfds, nullptr, nullptr, nullptr);
switch (s)
{
case 0:
//等待超时
std::cout << "time out: " << timeout.tv_sec << "." << timeout.tv_usec << std::endl;
break;
case -1:
//等待出错
std::cerr << "select error" << std::endl;
break;
default:
//有事件就绪
std::cout << "get a link" << std::endl; //如果上层一直不处理，底层则一直触发
Dispatcher(rfds);
break;
}
}
}
//Debug
void PrintFd()
{
std::cout << "online fd list: ";
for(int i = 0; i < fd_max; i++)
{
if(_rfd_array[i] != defaultfd)
std::cout << _rfd_array[i] << " ";
}
std::cout << std::endl;
}
~SelectServer()
{}
private:
MySocket _listensock;
uint16_t _port;
int _rfd_array[fd_max];
};- 服务器启动时，不能直接
accpet，因为accept的本质是检测并获取listensock上面的事件 struct timeval *timeout为输入输出型参数，需要周期性重复设置fd_set类型有大小，sizeof(fd_set) * 8即为最多设置位图个数fd_set *readfds/writefds/exceptfds都是输入输出参数，设置辅助数组，保留关系的文件描述符，然后重新设置- 获取链接之后，不能直接读取，如果直接读取，如果数据没有就绪，那就直接阻塞了，所以要将获取链接的文件描述符添加到辅助数组当中
select缺点
fd_set最多就是sizeof(fd_set)*8，所以等待的文件描述符有上限的- 输入输出参数较多，会频繁的从用户到内核、从内核到用户，数据拷贝频率较高；而且每次都要对关系的
fd进行重置，需要大量的遍历（用户层第三方数组管理需要遍历，内核中检测fd也需要遍历）