五种系统IO模型以及select/poll/epoll原理与使用教程(附带Reactor介绍)

已于 2022-08-26 09:59:20 修改
阅读量494 收藏 3
点赞数 1
分类专栏： 网络 文章标签： 网络 linux 服务器
于 2022-08-26 09:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Wyf_Fj/article/details/126534748
版权

文章目录

五种IO模型

一、什么是IO

IO的本质就是等待数据+拷贝数据，而IO的高效体现在是等待的比重较小。

网卡、键盘等硬件通过中断来通知CPU数据已到达。

其中，对于网络数据：

  1. 数据通过网线传输到网卡
  2. 网卡将数据写入内存
  3. 网卡通过中断信号告知CPU数据已到达

二、同步与异步

在探讨IO模型时，同步与异步用来形容方法的调用方式。

同步：在发出调用时，调用方必须等待方法执行完成并得到结果，才会继续向下执行；

异步：在发出调用时，方法就立即返回了，调用方无需等待方法执行完成，可以继续向下执行其它任务。当被调用方法执行完毕后，会主动通知调用方处理。

同步IO和异步IO的区别就在于：数据访问的时候进程是否需要阻塞等待！

阻塞与非阻塞

在探讨IO模型时，阻塞与非阻塞用来形容程序在等待调用结果时的状态。

阻塞是指：在调用结果返回之前，当前线程会被挂起。调用线程只有在得到结果之后才会被唤醒；

非阻塞是指：如果不能立刻得到结果之前，则该调用立刻返回并告知线程本次调用无果。因此，非阻塞需要采用轮询的方式多次调用以获取结果。

阻塞IO和非阻塞IO的区别就在于：应用程序的调用是否立即返回！

注：阻塞与同步、非阻塞与异步，在IO模型中是一一对应的关系。

三、同步阻塞IO模型

image-20220809152235951

若内核没有将数据准备好，那么调用方就会一直等待。

套接字和文件描述符默认都是阻塞方式。

四、同步非阻塞IO模型

image-20220809152312543

若内核数据没有就绪，那么系统调用会立即返回，这种情况需要通过轮询的方式不断地尝试读写。

由于文件描述符默认都是阻塞模式，因此我们需要fcntl()函数进行修改：

int fcntl(int fd, int cmd, ... /* arg */ )

  • fd：要操作的文件描述符；
  • cmd：要进行的操作，这里使用F_GETFL，即获取文件状态的标记flag，以及F_SETFL，即设置文件状态标记flag；
  • ...：可变参数，可以用来设置文件状态；
  • RetVal：如果是F_GETFL操作，那么成功会返回文件的状态flag；如果是F_SETFL操作，那么成功会返回0；失败返回-1。

示例：将fd修改为非阻塞模式

int flag = fcntl(fd, F_GETFL);  // 获取文件状态
flag |= O_NONBLOCK;        // 文件状态添加非阻塞模式
fcntl(fd, F_SETFL, flag);    // 设置新的文件状态

注：当文件描述符被设为非阻塞模式时，如果内核没有数据准备就绪，那么全局变量errno会被设置成EAGAIN或者EWOULDBLOCK；

五、信号驱动IO模型

若内核将数据准备好，会向进程发送信号SIGIO，从而触发对应的信号处理回调函数进行IO操作。

image-20220809154108058

在信号驱动IO模型中，等待数据到来的阶段是非阻塞的，而进程需要阻塞等待数据从内核拷贝至用户空间。

该模型较为复杂，实现起来有些困难。

六、异步IO模型

img

在异步IO模型中，等待数据到来的阶段和等待数据从内核拷贝至用户空间的阶段都是非阻塞的。

虽然效率极高，但是整体开发难度较大。

七、多路复用IO模型

多路复用，又称多路转接，本质上就是在一个线程下同时阻塞或非阻塞地等待多个文件是否发生事件(可读、可写等)。

相比于创建多线程等待多个文件，多路复用的方式能够节约线程调度消耗的资源。

image-20220809152416898

实现方式一、select

int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout)

  • nfds：所有文件描述符中的最大值 + 1。
  • readfds：读事件的输入输出型参数。作输入参数时，表示调用方关注对应文件是否可读；作输出参数时，用来通知用户有哪些关注的文件现在是可读的；为NULL表示不关注任何文件是否可读。
  • writefds：写事件的输入输出型参数，用法同readfds。
  • exceptfds：异常事件的输入输出型参数，用法同readfds。
  • timeout：为NULL表示以阻塞的方式调用select；为0表示非阻塞方式调用select；大于0表示在timeout这段时间内阻塞，超时就会返回。
  • RetVal：返回三个fd_set中描述符的总数量；如果出错则返回-1。
I. fd_set结构体

fd_set是一个位图结构，用来表示一个文件描述符集合。

Linux下用宏FD_SETSIZE来定义该位图能标识多少个文件描述符。

操作fd_set的相关接口：

  1. void FD_CLR(int fd, fd_set *set); // 用来清除set中相关fd的位
  2. int FD_ISSET(int fd, fd_set *set); // 用来查看set中相关fd的位是否为真
  3. void FD_SET(int fd, fd_set *set); // 用来设置set中相关fd的位
  4. void FD_ZERO(fd_set *set); // 用来清除set的全部位
II. timeval结构体
struct timeval
{
  __time_t tv_sec;        /* Seconds. */
  __suseconds_t tv_usec;  /* Microseconds. */
};

精确到微秒的时间结构体。

III. select的使用案例
const int SIZE = FD_SETSIZE;
// 一个基于select的服务器
class SelectServer
{
public:
    SelectServer(int port = 8081)
        : _port(port), _listenSock(-1)
    {
    }

    void InitSelectServer()
    {
        // 设置监听套接字
        _listenSock = Sock::Socket();
        // 设置无需TIME_WAIT
        int opt = 1;
        setsockopt(_listenSock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)); // 设置地址复用
        Sock::Bind(_listenSock, _port);
        Sock::Listen(_listenSock);  

        // 初始化套接字数组
        _fdArray[0] = _listenSock;
        for (int i = 1; i < SIZE; ++i)
        {
            _fdArray[i] = -1;
        }
    }

    void Loop()
    {
        while (1)
        {
            // 设置select需要关注读事件的文件描述符集
            fd_set readfds;
            FD_ZERO(&readfds);
            int maxFd = 0; // 记录最大的fd
            for (int i = 0; i < SIZE; ++i)
            {
                if (_fdArray[i] != -1)
                {
                    FD_SET(_fdArray[i], &readfds);
                    maxFd = std::max(maxFd, _fdArray[i]);
                }
            }
            struct timeval time = {0, 0}; // 非阻塞等待
            int n = select(maxFd + 1, &readfds, nullptr, nullptr, &time);
            if (n > 0) // 有读事件发生
            {
                for (int i = 0; i < SIZE; ++i)
                {
                    if (FD_ISSET(_fdArray[i], &readfds))
                    {
                        // 监听套接字可读，说明有新的连接请求
                        if (_fdArray[i] == _listenSock)
                        {
                            int sock = Sock::Accept(_listenSock);

                            // 将新套接字加入套接字数组
                            int j = 0;
                            for (; j < SIZE; ++j)
                            {
                                if (_fdArray[j] == -1)
                                {
                                    break;
                                }
                            }
                            if (j < SIZE)
                            {
                                _fdArray[j] = sock;
                                std::cout << "新的连接已建立: " << sock << std::endl;
                            }
                            else
                            {
                                std::cout << "连接已满!" << std::endl;
                                close(sock);
                            }
                        }
                        else
                        {
                            // 其它套接字可读，即用户发送数据，接收即可
                            char buffer[1024];
                            ssize_t s = recv(_fdArray[i], buffer, sizeof(buffer) - 1, 0);
                            if (s > 0)
                            {
                                buffer[s - 1] = 0;
                                std::cout << "已接收" << _fdArray[i] << "的数据# " << buffer << std::endl;
                                std::string msg = "服务器已收到数据!\n";
                                send(_fdArray[i], msg.c_str(), msg.size(), 0);
                            }
                            else if (s == 0)
                            {
                                std::cout << _fdArray[i] << "已断开连接" << std::endl;
                                close(_fdArray[i]);
                                _fdArray[i] = -1; // 从套接字数组中将其删除
                            }
                            else
                            {
                                std::cerr << "recv error!" << std::endl;
                                exit(4);
                            }
                        }
                    }
                }
            }
            else if (n == -1)
            {
                std::cerr << "select error!" << std::endl;
                exit(5);
            }
        }
    }

    ~SelectServer()
    {
        if (_listenSock != -1)
        {
            close(_listenSock);
        }
    }
private:
    uint16_t _port;
    int _listenSock;
    int _fdArray[SIZE];
};
IV. select的优缺点分析

优点：

  1. 对超时值精确到了微秒。
  2. 移植性更好，有些平台不支持poll。

缺点：

  1. 每次调用select都需要手动设置fd集合, 从接口使用角度来说也非常不便。
  2. 每次调用select都需要把fd集合从用户态拷贝到内核态，这个开销在fd很多时会很大。
  3. 每次调用select都需要在内核遍历传递进来的所有fd，这个开销在fd很多时也很大 。
  4. select支持的文件描述符数量太小，其值取决于FD_SERSIZE，其值通常为1024。

实现方式二、poll

int poll(struct pollfd *fds, nfds_t nfds, int timeout)

  • fds：输入输出型参数，pollfd数组指针，表示调用者关注哪些fd，作输出时用来查看哪些事件发生。
  • nfds：fds数组的大小。
  • timeout：以毫秒为单位；设为负数表示阻塞等待，0表示非阻塞，正数表示在一段时间内阻塞等待。
  • RetVal：返回有多少个fd有事件发生；出错返回-1。
I. pollfd结构体
struct pollfd
{
  int fd;            // 文件描述符
  short int events;  // 调用者关注fd的哪些事件，常用的有：POLLIN 读事件、 POLLOUT 写事件
  short int revents; // 实际fd发生了哪些事件
};
II. poll的使用案例
const int SIZE = 1024;
class PollServer
{
public:
	PollServer(int port = 8081)
		: _port(port), _listenSock(-1)
	{
	}

	void InitPollServer()
	{
		// 设置监听套接字
		_listenSock = Sock::Socket();
		// 设置无需TIME_WAIT
		int opt = 1;
		setsockopt(_listenSock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
		Sock::Bind(_listenSock, _port);
		Sock::Listen(_listenSock);  
		
		// 初始化pollfd数组
		_pollfds[0].fd = _listenSock;
		_pollfds[0].events = POLLIN; // 套接字设置关注读事件
		for (int i = 1; i < SIZE; ++i)
		{
			_pollfds[i].fd = -1;
			_pollfds[i].events = 0;
			_pollfds[i].revents = 0;
		}
	}

	void Loop()
	{
		while (1)
		{
			int n = poll(_pollfds, SIZE, 0); // 非阻塞等待
			if (n > 0) // 有读事件发生
			{
				for (int i = 0; i < SIZE; ++i)
				{
					if (_pollfds[i].revents & POLLIN)
					{
						// 监听套接字可读，说明有新的连接请求
						if (_pollfds[i].fd == _listenSock)
						{
							int sock = Sock::Accept(_listenSock);

							// 将新套接字加入套接字数组
							int j = 0;
							for (; j < SIZE; ++j)
							{
								if (_pollfds[j].fd == -1)
								{
									break;
								}
							}
							if (j < SIZE)
							{
								_pollfds[j].fd = sock;
								_pollfds[j].events = POLLIN; // 默认关注读事件
								std::cout << "新的连接已建立: " << sock << std::endl;
							}
							else
							{
								// 如果pollfds使用动态开辟的数组，那么这里可以选择将数组扩容！
								std::cout << "连接已满!" << std::endl;
								close(sock);
							}
						}
						else
						{
							// 其它套接字可读，即用户发送数据，接收即可
							char buffer[1024];
							ssize_t s = recv(_pollfds[i].fd, buffer, sizeof(buffer) - 1, 0);
							if (s > 0)
							{
								buffer[s - 1] = 0;
								std::cout << "已接收" << _pollfds[i].fd << "的数据# " << buffer << std::endl;
							}
							else if (s == 0)
							{
								std::cout << _pollfds[i].fd << "已断开连接" << std::endl;
								close(_pollfds[i].fd);
								_pollfds[i].fd = -1; // 从套接字数组中将其删除
							}
							else
							{
								std::cerr << "recv error!" << std::endl;
								exit(4);
							}
						}
					}
				}
			}
			else if (n == 0)
			{
				sleep(1);
				std::cout << "等待超时!" << std::endl;
			}
			else
			{
				std::cerr << "select error!" << std::endl;
				exit(5);
			}
		}
	}

	~PollServer()
	{
		if (_listenSock != -1)
		{
			close(_listenSock);
		}
	}

private:
	uint16_t _port;
	int _listenSock;
	struct pollfd _pollfds[SIZE];
};
III. poll的优缺点分析

poll的优点：

  1. 没有文件描述符数量的限制。

  2. 接口使用相比select更加方便。

poll的缺点：

  1. 与select一样，poll返回后，需要轮询pollfd来获取就绪的描述符。

  2. 将pollfd结构体数组从用户拷贝到内核有较大的消耗。

实现方式三、epoll

epoll的使用基于三个接口：

1、int epoll_create(int size)

  • size：Linux 2.6.8版本之后，size就被忽略了，只要设置成大于0的值即可。在此之前，size用来表示调用者期望关注的文件描述符数量；
  • RetVal：成功则返回一个文件描述符，用于后续epoll的相关操作；失败则返回-1。

2、int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)

  • epfd：epoll_create返回的文件描述符
  • op：操作选项，包括EPOLL_CTL_ADD(添加关注的fd)、EPOLL_CTL_MOD(修改关注的fd的事件)、EPOLL_CTL_DEL(删除关注的fd)；

注：在Linux_2.6.9之前，如果选项为EPOLL_CTL_DEL，event参数也不得为空，在此版本之后，event可以设为NULL；

  • fd：op操作的文件描述符

  • event：包括关注的文件描述符、关注的事件

  • RetVal：成功返回0，失败返回-1

相关结构体：

struct epoll_event
{
  uint32_t events;   // 调用者关注的事件，包括：EPOLLIN(读)、EPOLLOUT(写)，EPOLLERR(错误)，可按位或
  epoll_data_t data; // 用来存储数据的联合体，通常是我们关注的文件的相关信息，比如epoll_data.fd；
};

typedef union epoll_data
{
  void *ptr;
  int fd;
  uint32_t u32;
  uint64_t u64;
} epoll_data_t;

3、int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout)

  • epfd：epoll_create()返回的文件描述符
  • events：一个输出型数组(需要我们自己分配内存)，用来接收有哪些fd、发生了什么事件；
  • maxevents：表示本次等待最多处理的事件个数，该值不能超过events数组的大小；
  • timeout：超时时间，以毫秒为单位。其中-1表示阻塞式等待，0表示非阻塞；
  • RetVal：成功则返回有多少个文件描述符有事件发生；失败则返回-1。
I. epoll的使用案例
const int NUM = 10;

class EpollServer
{
public:
	EpollServer(uint16_t port = 8081)
		: _port(port)
		, _listenSock(-1)
		, _epfd(-1)
	{
		// 初始化events数组，用于接收待处理的事件
		_events = new epoll_event[NUM];
	}

	void InitEpollServer()
	{
		// 初始化epoll套接字
		_epfd = epoll_create(1);

		// 初始化监听套接字
		_listenSock = Sock::Socket();

		// 取消监听套接字的TimeWait
		int opt = 1;
		setsockopt(_listenSock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
		
		Sock::Bind(_listenSock, _port);
		Sock::Listen(_listenSock);

		// 将监听套接字添加至epoll
		struct epoll_event event;
		event.events = EPOLLIN;
		event.data.fd = _listenSock;
		epoll_ctl(_epfd, EPOLL_CTL_ADD, _listenSock, &event);
	}

	void Loop()
	{
		while (1)
		{
			int n = epoll_wait(_epfd, _events, NUM, 1000); // 最长等待1000ms
			switch (n)
			{
			case 0:
				std::cout << "timeout!" << std::endl;
				break;
			case -1:
				std::cerr << "epoll_wait error!" << std::endl;
				exit(1);
				break;
			default:
				Handler(n);
				break;
			}
		}
	}

	~EpollServer()
	{
		if (_listenSock != -1)
		{
			close(_listenSock);
		}
		if (_epfd != -1)
		{
			close(_epfd);
		}
	}
private:
	void Handler(int n)
	{
		for (int i = 0; i < n; ++i)
		{
			int sock = _events[i].data.fd;
			// 有读事件发生
			if (_events[i].events & EPOLLIN)
			{
				// 监听套接字发生读事件，说明有新的连接请求
				if (sock == _listenSock)
				{
					int newSock = Sock::Accept(_listenSock);
					std::cout << "接收到新的连接请求# " << newSock << std::endl;

					// 将新套接字添加至epoll
					struct epoll_event event;
					event.data.fd = newSock;
					event.events = EPOLLIN;
					epoll_ctl(_epfd, EPOLL_CTL_ADD, newSock, &event);
				}
				else
				{
					// 普通套接字可读
					char buffer[1024];
					ssize_t s = recv(sock, buffer, sizeof(buffer) - 1, 0);
					if (s > 0)
					{
						buffer[s - 1] = 0;
						std::cout << "接收到" << sock << "发送的数据# " << buffer << std::endl;

						// 对收到的数据进行反馈，需要先等待写事件
						struct epoll_event event;
						event.data.fd = sock;
						event.events = EPOLLIN | EPOLLOUT;
						epoll_ctl(_epfd, EPOLL_CTL_MOD, sock, &event);
					}
					else if (s == 0)
					{
						// 对端已关闭连接，将其从epoll中删除，并关闭文件描述符
						struct epoll_event event;
						epoll_ctl(_epfd, EPOLL_CTL_DEL, sock, &event);
						close(sock);
						std::cout << sock << "已断开连接" << std::endl;
					}
					else
					{
						std::cerr << "recv error!" << std::endl;
						exit(2);
					}
				}
			}

			// 有写事件发生
			if (_events[i].events & EPOLLOUT)
			{
				int sock = _events[i].data.fd;
				std::string msg = "服务器# 已收到你的信息！\n";
				send(sock, msg.c_str(), msg.size(), 0);
				
				// 由于这里只是对客户端信息进行一次反馈，之后不再关注写事件
				struct epoll_event event;
				event.data.fd = sock;
				event.events = EPOLLIN;
				epoll_ctl(_epfd, EPOLL_CTL_MOD, sock, &event);
			}
		}
	}

private:
	uint16_t _port; // 服务端口号
	int _listenSock; // 监听套接字
	int _epfd; // epoll文件描述符
	struct epoll_event* _events; // 用于接收待处理的事件
};
II. epoll的底层原理

  1. 当用户调用epoll_create()时，内核会创建一个eventpoll对象，该对象是文件系统中的一员，因此拥有自己的fd，也就是epoll_create()返回的epfd；

  2. eventpoll维护了一棵**红黑树作为epoll的“监视列表”，红黑树的每一个节点包括了fd(socket)、用户关注该fd的哪些事件(event)等数据。当用户调用epoll_ctl()时，实际上就是对这棵红黑树进行增删查改**的操作；

  3. 当有新的fd被添加到epoll的监视列表中时，内核为每一个fd对应的设备驱动(如网卡)注册一个回调函数；

  4. eventpoll还维护了一个双向链表作为epoll的**“就绪队列”，其中每个节点包括了fd、该fd发生了哪些用户关注的事件等数据。当epoll监视的fd有关注事件发生时，对应的设备驱动就会通过回调函数**将这些数据写入节点并添加至双向链表中。

  5. 当用户调用epoll_wait()时，内核直接查看双向链表中是否有节点。如果有，就将相关数据写入到events数组中并拷贝至用户空间，同时在链表中删除对应节点。

III. epoll工作方式
  • 水平触发(LT, Level Trigger)

在该模式下：

对于读操作：只要缓冲区还有数据没有读完，就返回读就绪；

对于写操作：只要缓冲区还没满，就返回写就绪。

总之，如果没有一次读写完数据，那么就会一直通知有事件发生。

  • 边缘触发(ET, Edge Trigger)

在该模式下：

对于读操作：

  1. 缓冲区有新数据到达时，返回读就绪
  2. 缓冲区有数据可读，且应用进程为相应的描述符添加EPOLLIN事件时，返回读就绪。

对于写操作：

  1. 缓冲区旧数据被取走，有空间可写时，返回写就绪

  2. 缓冲区有空间可写，且应用进程为相应的描述符添加EPOLLOUT事件时，返回写就绪。

即：只有在发生变化时(缓冲区数据变化、事件变化)，才会通知有事件发生。

  • LT与ET对比

  1. ET模式相比于LT模式减少了通知次数，因此效率更高；

  2. ET模式只会通知一次，因此迫使用户必须在一次通知到来时将数据读取完毕，而LT模式下可以一次读取一部分，因为下一次依然会有通知到来；

  3. LT模式支持阻塞和非阻塞读写方式，而**ET只能是非阻塞读写**。因为：ET模式必须一次性读完数据，而每一次读取的buffer是有限大小，因此需要循环读取！如果是阻塞方式，那么在循环读取的最后一次，一旦没有数据了，这一次读取就会被挂起，也就是整个服务进程被挂起！

  4. select()和poll()只能是LT模式，而epoll可以通过令epoll_ctl()的op=EPOLLET设置某个fd的事件通知是ET模式。

epoll与select/poll的对比

  1. select/poll都是由系统以遍历的方式去检测特定的fd是否有事件发生；而epoll是通过注册回调函数的方式，将fd和发生的事件添加至就绪队列，每一次epoll只需要检测队列是否有节点即可，效率更高。
  2. select/poll每次都要用户将关注的fd拷贝至内核，检测完成后再由内核拷贝结果给用户，且用户需要再完成一次遍历检测哪些fd发生了事件；而epoll在内核维护了一个红黑树管理用户关注的fd：一方面，不需要用户维护这些fd，另一方面，红黑树的增删查改效率相比数组更高；此外，epoll只需要将就绪队列中的节点返回给用户即可，无需内核遍历所有关注的fd，同时也节省了用户遍历检测的时间，效率更高。
  3. 相比于select，epoll不再有检测的fd有数量上限的问题。

八、Reactor(反应堆)设计模式

反应堆设计模式(Reactor pattern)是一种高效处理并发服务请求的设计模式。

它是基于epoll多路复用的事件驱动模式，只需要添加用户关心的事件，当事件发生后，Reactor事件派发方法就会自动调用该事件注册的回调函数进行处理。该处理可以由事件派发方法完成，也可以由线程池的线程去完成。

img

因此，Reactor模式的优势在于：

  1. 使用多路复用，IO效率高。

  2. 仅负责监听并派发事件，而事件的处理回调函数由用户提供，因此做到了将“事件处理”和“事件监听、派发”解耦，具有很高的框架复用性。

  3. 可以增加Reactor实例，进一步提高CPU利用率。

多Reactor实例的实现思路

1、多线程/进程创建多个Reactor实例，通过管道建立它们之间的通信信道。

2、主进程/线程的Reactor只负责监听套接字的accept工作。当有新连接时，将fd通过管道**负载均衡**地派发给其余的Reactor。

3、其余进程/线程获取到fd后，将其添加至Reactor中，并等待事件派发。

白龙码~
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
网络io与io多路复用select/poll/epoll 服务器并发代码实现
08-29
网络io与io多路复用select/poll/epoll 服务器并发代码实现
linux内核select/poll，epoll实现与区别
12-31
下面文章在这段时间内研究 select/poll/epoll的内核实现的一点心得体会： select，poll，epoll都是多路复用IO的函数，简单说就是在一个线程里，可以同时处理多个文件描述符的读写。 select/poll的实现很类似，epoll是从select/poll扩展而来，主要是为了解决select/poll天生的缺陷。 epoll在内核版本2.6以上才出现的新的函数，而他们在linux内核中的实现都是十分相似。 这三种函数都需要设备驱动提供poll回调函数，对于套接字而言，他们是 tcp_poll，udp_poll和datagram_poll; 对于自己开发的设备驱动而言，是自
IO模型介绍（select、poll、epoll）
最新发布
京东零售技术的博客
03-11 876
IO模型即输入输出模型，本文作者通过redis单线程模型原理的运用，解决了多并发问题，阅读本文您可以了解到五种常见的IO模型。
2.1 网络io、io多路复用select/poll/epoll、基于事件驱动的reactor
Ricardo2的博客
05-31 1056
网络I/O请求是指在计算机网络中，向其他主机或服务器发送请求或接收响应的操作。这些请求可以包括获取网页、下载文件、发送电子邮件等。网络I/O请求需要使用合适的协议和通信方式来进行数据传输，例如HTTP、FTP、SMTP等。要完成一个完整的 TCP/IP 网络通信过程，需要使用一系列函数来实现。这些函数包括 bind、listen、accept 和 recv/send 等。对于第4步的请求，如果向下面方式处理，则只能接受一个客户端的请求。
select、poll、epoll、reactor总结
qq_48243698的博客
03-22 1208
//select模型 fd_set fdSocket; //套接字集合 ，默认最大值FD_SETSIZE FD_ZERO(&fdSocket); //初始化fd_set集合，集合在使用前应该清空 FD_SET(sListen, &fdSocket); //将套接字添加到集合 while (1) { fd_set fdRead = fdSocket; //将一个套接字拷贝赋给select函数 //用于接..
小结下select模型，poll模型和epoll模型
两眼一睁 神志不清
10-29 839
关于selece，poll和epoll模型的总结 首先select，poll，epoll都是IO多路复用的机制，先是监听多个文件的描述符fd，一旦某个fd就绪后，就可以进行相应的读写操作。select，poll，epoll从本质上讲都是同步I/O，都需要在读写时间就绪之后自己负责读写，这个过程时阻塞的。 上图就是多路复用模型，同其他io不同的是，IO多路复用一次可以等待多个文件描述符，大...
多路转接——select、poll和epoll以及Reactor模式
m0_60748489的博客
07-30 115
多路转接，select，poll，epoll，Reactor，事件驱动
poll&epll 模型
u011550549的博客
11-14 315
POLL网络编程模型 PIPE信号的产生与处理，如何减少time_wait。 1.首先是创建socket，设置ip端口。（socket_nonbock,socket_closexec）每个socket都有自己的输入缓冲区和输出缓冲区。 2.再是设置端口复用，绑定端口，监听端口。 3.定义poll event结构和events数组，将监听的事件的描述符加到poll event中，并且监听po...
IO模型及select、poll、epoll和kqueue的区别
单向街的夏天
06-01 5825
先说下本文框架，先是问题引出，然后概括两个机制的区别和联系，最后介绍每个接口的用法 一、问题引出 联系区别 问题的引出，当需要读两个以上的I/O的时候，如果使用阻塞式的I/O，那么可能长时间的阻塞在一个描述符上面，另外的描述符虽然有数据但是不能读出来，这样实时性不能满足要求，大概的解决方案有以下几种： 1.使用多进程或者多线程，但是这种方法会造成程序的复杂，而且对与进程与线程的创
网络io使用实例 select，poll，epoll
03-08
网络io的使用实例 1.阻塞 2.多线程 3.select 4.poll， 5.epoll
Linux网络编程，包括tcp/upd，select/poll/epoll/pdf
04-14
它主要涉及到TCP/UDP协议以及select/poll/epoll等多路复用技术。 TCP/UDP协议是网络通信的基础，其中TCP协议提供面向连接的可靠数据传输，而UDP协议则提供无连接的不可靠数据传输。在Linux网络编程中，开发者需要...
IO模型、select、poll、epoll
m0_55752775的博客
06-05 620
函数select() 返回值为0、-1或者一个大于1的整数值：当监视的文件集中有文件描述符符合要求，即读文件描述符集中的文件可读、写文件描述符中的文件可写或者错误文件描述符中的文件发生错误时，返回值为大于0的正值；当超时的时候返回0；使用IO复用模型可以在等待的时候加入超时的时间，当超时时间没有到达的时候，阻塞的情况一致，而当超时间到达仍然没有数据接收到，系统会返回，不再等待，select()函数按照一定的超时时间轮询，直到需要等待的套接字有数据到来，利用recvfrom()函数将数据复制到应用层。
深入理解select、poll和epoll及区别
Dayu_log的博客
11-02 566
select poll epoll
select、poll、epoll、多线程在多任务并发设计中的应用
weixin_58016534的博客
06-03 820
这三个的运行结果大家可以参见前几期分享的《使用select实现TCP并发服务器模型》一文，运行结果是完全一致的，那么到这里呢，tcp并发服务器模型在目前已经给大家介绍了四个了，所以大家可以用这个模型着手去做其他服务器多任务并发的设计，以此实现更加符合人们需求的产品！
Linux学习笔记14—IO多路复用：select/poll/epoll与Reactor模式
CS_boy的博客
09-13 847
来个offer吧（少年祈祷中）
select、poll、epoll各自的特性、区别和相同点
ZZU_LGY
04-09 4545
支持大规模文件描述符：在支持 1024 个文件描述符的系统中，使用 select 或 poll 等函数，需要用户将要监听的文件描述符复制到内核中，这样，内核会消耗大量的开销来维护多个文件描述符这样的数组。epoll 可以监听的文件描述符数量非常多，而且能够双向扫描，具有更高的效率。适合于小规模连接：由于 select 内核使用了轮询的方式遍历文件描述符，并且每次调用 select 需要将文件描述符集合从用户空间拷贝到内核空间，因此 select 对于大规模连接的场景支持有限，适合小规模连接的处理。
三种IO多路复用模型-select、poll、epoll
lans_g的博客
05-11 1580
IO多路复用是指内核一旦发现进程指定的一个或者多个IO条件准备读取，它就通知该进程。 IO多路复用适用如下场合： 1.当客户处理多个描述符时（一般是交互式输入和网络套接口），必须使用I/O复用。 2.当一个客户同时处理多个套接口时，而这种情况是可能的，但很少出现。 3.如果一个TCP服务器既要处理监听套接口，又要处理已连接套接口，一般也要用到I/O复用。 4.如果一个服务器即要处理TCP，又要处理UDP，一般要使用I/O复用。 5.如果一个服务器要处理多个服务或多个协议，一般要使用I/O复用。 目前支持
select/poll/epoll
07-27
select、poll和epoll都是I/O多路复用机制，用于同时监听多个I/O事件的状态。它们的基本原理是通过查询所有socket连接，如果有数据到达，就通知用户进程。\[2\]这些机制都属于同步I/O，需要在事件就绪后自己负责读写，并且读写过程会阻塞。而异步I/O则不会自己读写和阻塞，而是负责将数据从内核拷贝到用户空间。\[3\] select是最早出现的I/O多路复用机制，它使用fd_set数据结构来存储需要监听的文件描述符，通过调用select函数来等待事件的发生。select的缺点是效率较低，因为每次调用select都需要将所有的文件描述符集合传递给内核，而且select的文件描述符数量有限制。\[1\] poll是select的改进版本，它使用pollfd数据结构来存储需要监听的文件描述符，通过调用poll函数来等待事件的发生。poll相对于select的优点是没有文件描述符数量的限制，但仍然需要将所有的文件描述符集合传递给内核。\[1\] epoll是Linux特有的I/O多路复用机制，它使用epoll_event数据结构来存储需要监听的文件描述符，通过调用epoll_ctl函数来注册事件，然后通过调用epoll_wait函数来等待事件的发生。epoll的优点是没有文件描述符数量的限制，而且在注册事件时只需要拷贝一次文件描述符到内核，而不是在等待事件时重复拷贝。epoll还支持水平触发和边沿触发两种模式，边沿触发模式可以降低同一个事件被重复触发的次数。\[1\] 总结来说，select、poll和epoll都是用于实现I/O多路复用的机制，它们的选择取决于具体的应用场景和需求。select适用于连接数量多但活动连接较少的情况，poll适用于连接数量多且活动连接较多的情况，而epoll适用于连接数量多但活动连接较少的情况，并且具有更高的效率和更灵活的触发模式。\[1\] #### 引用[.reference_title] - *1* *3* [select、poll、epoll简介](https://blog.csdn.net/HuYingJie_1995/article/details/130516595)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* [select、poll、epoll详解](https://blog.csdn.net/ljjjjjjjjjjj/article/details/129720990)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

白龙码~

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值