Linux学习记录——사십 高级IO（1）

---

其它IO类型的实现在这篇之后的三篇

1、IO

input，output。调用read或recv接口时，如果对方长时间不向我方接收缓冲区拷贝数据，我们的进程就只能阻塞，这是读取条件不满足。阻塞的时间成本最后会体现在用户上。因此可以说，IO = 等 + 数据拷贝。高效IO则是单位事件内，等的比重越低，IO效率越高。

可以看出IO是有条件的，满足条件就叫IO时间就绪。

IO有五种模型

2、同、异步IO（5种IO类型）

调用读取用的接口后，对于有自己的接收缓冲区，有5种IO方式

阻塞IO：如果缓冲区内没有好数据，系统调用就一直阻塞等待，不做别的事情，直到准备好数据，才开始读取并返回。所有的套接字默认都是阻塞IO。

非阻塞IO：单次检验缓冲区内没有数据，recv函数就返回EWOULDBLOCK，每隔一段时间再调用recv接口来查看缓冲区，如果有就读取并返回数据，没有就还返回上面的。这也就是非阻塞轮询。

阻塞与非阻塞的区别在于等的方式不同，不过都要自己去拷贝数据。非阻塞在没得到结果前就不阻塞当前进程，直接返回，过一会再来查看；阻塞就是一直阻塞等待，直到读取数据再返回。

上面两个等的方式不同，但拷贝方式相同。

信号驱动IO：缓冲区内有数据时，就发送SIGIO信号通知上层调用接口来读取。信号是告知上层什么时候可以读取的，接口是在信号处理了之后才调用的。

recv函数调用后会先检测有没有数据，也就是条件检测，没有返回，有才读取再返回。像这样的接口只使用一个文件描述符。

多路复用/多路转接IO：执行一个进程，传多个文件描述符，调用多个接口来等待数据，进程只负责等待数据，等到有了数据，也就是IO条件就绪，就通知上层调用recv接口来读取并返回。

多路复用IO是效率最高的，因为并不只是一个进程在等，而是很多个进程在等，那么等待成功的可能性就更高。单个进程等待的概率和多个进程等待的概率相比。

上面4个都是同步IO。

异步IO：不参与等待过程，只是发起一个进程，给一个缓冲区来接收数据。至于结果怎么样，由操作系统来决定。多路复用是进程在等待，异步IO是系统在等待。

两种IO方式的区别是有没有参与等以及读取的过程。实际上，对应到系统，应当是一个进程通过特定的文件描述符，等待IO事件就绪，通过系统调用来读取数据拷贝到上层。

recv函数就是在做条件检测，条件通过再读取。

3、其它高级IO

记录锁、系统V流机制。存储映射IO（mmap），readv和writev函数等

4、非阻塞IO

int main()
{
	char buffer[64];
	while(true)
	{
		printf(">>> ");
		fflush(stdout);
		ssize_t n = read(0, buffer, sizeof(buffer) - 1);
		if(n > 0)
		{
			buffer[n - 1] = 0;
			std::cout << "echo# " << buffer << std::endl;
		}
	}
}

这就是一个等待的过程，如果我们不输入，就一直卡在read那里。这是阻塞，如果要变成非阻塞，用fcntl接口。

#include <fcntl.h>
int fcntl(int fd, int cmd, …/* arg */);

cmd值有5种

复制一个现有的描述符（cmd=F_DUPFD）
获得/设置文件描述符标记(cmd=F_GETFD或F_SETFD)
获得/设置文件状态标记(cmd=F_GETFL或F_SETFL)//GET获得文件状态标记位，SET设置这个文件新的状态
获得/设置异步I/O所有权(cmd=F_GETOWN或F_SETOWN)
获得/设置记录锁(cmd=F_GETLK，F_SETLK或F_SETLKW)

void SetNonBlock(int fd) {
	int fl = fcntl(fd, F_GETFL);//使用F_GETFL将当前的文件描述符的属性取出来(这是一个位图)
	if (fl < 0) {
 		perror("fcntl");
 		return; 
 	}
	fcntl(fd, F_SETFL, fl | O_NONBLOCK);//然后再使用F_SETFL将文件描述符设置回去. 设置回去的同时, 加上一个O_NONBLOCK参数
}

非阻塞和阻塞都是文件的读取方式，在文件结构体中就是一个变量设为1或0，这里的O_NONBLOCK是宏，只有一个比特位，通过fcntl将这个数设置进文件结构体。

#include <iostream>
#include <fcntl.h>
#include <unistd.h>
#include <cstdio>
#include <cstring>

void SetNonBlock(int fd)
{
	int fl = fcntl(fd, F_GETFL);//使用F_GETFL将当前的文件描述符的属性取出来(这是一个位图)
	if (fl < 0)
    {
        std::cerr << "error string: " << strerror(errno) << " error code: " << errno << std::endl;
        return ;
    }
	fcntl(fd, F_SETFL, fl | O_NONBLOCK);//然后再使用F_SETFL将文件描述符设置回去. 设置回去的同时, 加上一个O_NONBLOCK参数
}

int main()
{
	char buffer[64];
    //SetNonBlock(0);//0表示非阻塞
	while(true)
	{
		printf(">>> ");
		fflush(stdout);
		ssize_t n = read(0, buffer, sizeof(buffer) - 1);
		if(n > 0)
		{
			buffer[n - 1] = 0;
			std::cout << "echo# " << buffer << std::endl;
		}
        else if(n == 0)
        {
            std::cout << "end file" << std::endl;
            break;
        } 
        else
        {
            std::cout << "read error??" << std::endl;
            break;
        } 
	}
}

不设置成0，就是阻塞。read那里不是0而是4，当前没有打开文件描述符为4的文件，就会read error。加上错误原因

        else
        {
            std::cerr << "read error?" << "error string: " << strerror(errno) << " error code: " << errno << std::endl;
            break;
        } 

现在再用上SetNonBlock，设置为0，那么即使不输入，也会出错，因为它不阻塞，直接去判断，没输入也没读取完，所以就打印错误语句

那么这里就在每一次循环后sleep一会。只有在输入时才会打印正常语句，不输入就一直打印错误语句。非阻塞IO在底层没有数据时，就以出错形式返回，不过不算正式地出错。

区分一下

        else
        {
            if(errno == EAGAIN || errno == EWOULDBLOCK)//也就是错误码为11的两个，表示非阻塞式的出错返回
            {
                //底层数据没有准备好，下次继续检测
                sleep(1);
                std::cout << "data not ready" << std::endl;
                continue;
            }
            else if(errno == EINTR)
            {
                //这次IO被信号中断，需要重新读取
                continue;
            }
            std::cerr << "read error? " << "error string: " << strerror(errno) << " error code: " << errno << std::endl;
            break;
        }

非阻塞IO在没有得到数据之前，可以做别的工作，模拟一下：

#include <iostream>
#include <unistd.h>
#include <fcntl.h>
#include <cstdio>
#include <cstring>
#include <vector>
#include <functional>

void PrintLog()
{
    std::cout << "这个是一个日志例程" << std::endl;
}

void OpenMysql()
{
    std::cout << "这个是一个操作数据库的例程" << std::endl;
}

void CheckNet()
{
    std::cout << "这个是一个检测网络状态的例程" << std::endl;
}

using func_t = std::function<void (void)>;
std::vector<func_t> funcs;

void LoadTask()
{
    funcs.push_back(PrintLog);
    funcs.push_back(OpenMysql);
    funcs.push_back(CheckNet);
}

void HandlerAllTask()
{
    for(const auto& func: funcs) func();
}

void SetNonBlock(int fd)
{
	int fl = fcntl(fd, F_GETFL);//使用F_GETFL将当前的文件描述符的属性取出来(这是一个位图)
	if (fl < 0)
    {
        std::cerr << "error string: " << strerror(errno) << " error code: " << errno << std::endl;
        return ;
    }
	fcntl(fd, F_SETFL, fl | O_NONBLOCK);//然后再使用F_SETFL将文件描述符设置回去. 设置回去的同时, 加上一个O_NONBLOCK参数
}

int main()
{
	char buffer[64];
    SetNonBlock(0);//0表示非阻塞
    LoadTask();
	while(true)
	{
		printf(">>> ");
		fflush(stdout);
		ssize_t n = read(0, buffer, sizeof(buffer) - 1);
		if(n > 0)
		{
			buffer[n - 1] = 0;
			std::cout << "echo# " << buffer << std::endl;
		}
        else if(n == 0)
        {
            std::cout << "end file" << std::endl;
            break;
        }
        else
        {
            if(errno == EAGAIN || errno == EWOULDBLOCK)//也就是错误码为11的两个，表示非阻塞式的出错返回
            {
                //底层数据没有准备好，下次继续检测
                HandlerAllTask();
                sleep(1);
                std::cout << "data not ready" << std::endl;
                continue;
            }
            else if(errno == EINTR)
            {
                //这次IO被信号中断，需要重新读取
                continue;
            }
            std::cerr << "read error? " << "error string: " << strerror(errno) << " error code: " << errno << std::endl;
            break;
        }
        sleep(3); 
	}
}

本篇gitee

结束。