多路复用详解

最新推荐文章于 2025-04-21 16:54:32 发布
最新推荐文章于 2025-04-21 16:54:32 发布
阅读量148 收藏
点赞数
分类专栏： 嵌入式进阶之路 文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/u012046122/article/details/140419317
版权

LInux系统编程面试会问你点啥问题？

​ 进程和线程有啥区别

​ 网络编程七层模型

​ TCP UDP的区别

​ TCP三次握手

​ 进程间通信有哪些方式

​ 用过多路复用？ 各有什么特点？

​ select ,缺点 一个进程中最多只能监测1024个设备

​ poll, 一个进程可以监测超过1024个设备

​ 但是select 和poll监测的效率低（轮询机制）

​ epoll, 效率更高 （回调机制）

多路复用

目前支持I/O多路复用的系统调用有 select，pselect，poll，epoll，I/O多路复用就是通过一种机制，一个进程可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或者写就绪），能够通知程序进行相应的读写操作。

与多进程和多线程技术相比，I/O多路复用技术的最大优势是系统开销小，系统不必创建进程/线程，也不必维护这些进程/线程，从而大大减小了系统的开销。

1.使用 场景

IO多路复用是指内核一旦发现进程指定的一个或者多个IO条件准备读取，它就通知该进程。IO多路复用适用如下场合：

1）当客户处理多个描述符时（一般是交互式输入和网络套接口），必须使用I/O复用。

2）当一个客户同时处理多个套接口时，这种情况是可能的，但很少出现。

3）如果一个TCP服务器既要处理监听套接口，又要处理已连接套接口，一般也要用到I/O复用。

4）如果一个服务器即要处理TCP，又要处理UDP，一般要使用I/O复用。

5）如果一个服务器要处理多个服务或多个协议，一般要使用I/O复用。

2.select

epoll跟select都能提供多路I/O复用的解决方案。在现在的Linux内核里有都能够支持，其中epoll是Linux所特有，而select则应该是POSIX所规定，一般操作系统均有实现。

**基本原理：**select 函数监视的文件描述符分3类，分别是writefds、readfds、和exceptfds。调用后select函数会阻塞，直到有描述符就绪（有数据 可读、可写、或者有except），或者超时（timeout指定等待时间，如果立即返回设为null即可），函数返回。当select函数返回后，可以通过遍历fdset，来找到就绪的描述符。

select目前几乎在所有的平台上支持，其良好跨平台支持也是它的一个优点。select的一个缺点在于单个进程能够监视的文件描述符的数量存在最大限制，在Linux上一般为1024，可以通过修改宏定义甚至重新编译内核的方式提升这一限制，但是这样也会造成效率的降低。

select本质上是通过设置或者检查存放fd标志位的数据结构来进行下一步处理。这样所带来的缺点是：

  • select最大的缺陷就是单个进程所打开的FD是有一定限制的，它由FD_SETSIZE设置，默认值是1024**。**

    可以通过cat /proc/sys/fs/file-max察看。

  • 进行扫描时是线性扫描，即采用轮询的方法，效率较低。

当套接字比较多的时候，每次select()都要通过遍历FD_SETSIZE个Socket来完成调度，不管哪个Socket是活跃的，都遍历一遍。这会浪费很多CPU时间。

  • 需要维护一个用来存放大量fd的数据结构，这样会使得用户空间和内核空间在传递该结构时复制开销大

  • 需要在返回后，通过遍历文件描述符来获取已经就绪的文件。事实上，同时连接的大量客户端在一时刻可能只有很少的处于就绪状态，因此随着监视的描述符数量的增长，其效率也会线性下降。

    动图封面

int select(int numfds, fd_set *readfds, fd_set *writefds，fd_set *exeptfds, 
           struct timeval *timeout)
	numfds ： 该参数值为需要监视的文件描述符的最大值加1

	readfds ： 由select()监视的读文件描述符集合

	writefds ：由select()监视的写文件描述符集合

	exeptfds ：由select()监视的异常处理文件描述符集合
	返回值：大于0成功，返回准备好的文件描述符的数目；0时，超时；-1时，出错。
FD_ZERO(fd_set *set)， 清除一个文件描述符集
FD_SET(int fd, fd_set *set)， 将一个文件描述符加入文件描述符集中
FD_CLR(int fd, fd_set *set)， 将一个文件描述符从文件描述符集中清除
FD_ISSET(int fd, fd_set *set)， 如果文件描述符fd 为fd_set 集中的一个元素，则返回非零值，可以用于调用select()之后测试文件描述符集中的文件描述符是否有变化

struct timeval
{
	long tv_sec; /* 秒 */
	long tv_unsec; /* 微秒 */
}


#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/select.h>
#include <sys/time.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
 
/* 定义一个宏用来求两个数中的最大值 */
#define MAX(a, b)	((a) > (b) ? (a) : (b))
 
/* 定义缓冲区的大小 */
#define BUFFER_SIZE		512
 
/* 程序的入口函数 */
int main(int argc, char *argv[])
{
	int fd0, fd1, fd2, max_fd;
	fd_set read_set, tmp_set;
	char buf[BUFFER_SIZE];
	int ret, read_len;
 
	/* 打开三个文件 */
	if((fd0 = open("in0", O_RDONLY|O_NONBLOCK)) < 0)
	{
		printf("open in0 error!\n");
		return -1;
	}
	if((fd1 = open("in1", O_RDONLY|O_NONBLOCK)) < 0)
	{
		printf("open in1 error!\n");
		return -1;
	}
	if((fd2 = open("in2", O_RDONLY|O_NONBLOCK)) < 0)
	{
		printf("open in2 error!\n");
		return -1;
	}
 
	/* 取出三个文件描述符当中最大的一个 */
	max_fd = MAX(MAX(fd0, fd1), fd2);
 
	/* 初始化read_set文件描述符集合 */
	FD_ZERO(&read_set);
	FD_SET(fd0, &read_set);
    FD_SET(fd1, &read_set); 
    FD_SET(fd2, &read_set);
 
	/* 进入循环操作 */
	while(1)
	{
		tmp_set = read_set;
		/*
		 *	监视三个文件的读操作，一直等待
		 *		返回值 : 0 超时 -1 出错 大于0 成功
		 */
		ret = select(max_fd + 1, &tmp_set, NULL, NULL, NULL);
 
		if(ret < 0)		/* 出错 */
		{
			printf("select error!\n");
			return -1;
		}
		else if (ret == 0)	/* 超时 */
		{
			printf("time out!\n");
			return 0;
		}
		else if(ret > 0)	/* 成功 */
		{
			if(FD_ISSET(fd0, &tmp_set))	/* in0 有数据可读 */
			{
				memset(buf, 0, BUFFER_SIZE);
				read_len = read(fd0, buf, BUFFER_SIZE);
				if(read_len > 0)
				{
					buf[read_len] = '\0';
					printf("Read from in0 : %s\n", buf);
				}
			}
			if(FD_ISSET(fd1, &tmp_set))	/* in1 有数据可读 */
			{
				memset(buf, 0, BUFFER_SIZE);
				read_len = read(fd1, buf, BUFFER_SIZE);
				if(read_len > 0)
				{
					buf[read_len] = '\0';
					printf("Read from in1 : %s\n", buf);
				}
			}
			if(FD_ISSET(fd2, &tmp_set))	/* in2 有数据可读 */
			{
				memset(buf, 0, BUFFER_SIZE);
				read_len = read(fd2, buf, BUFFER_SIZE);
				if(read_len > 0)
				{
					buf[read_len] = '\0';
					printf("Read from in2 : %s\n", buf);
				}
			}
		}
	}
	
	return 0;
}

mkfifo in0
mkfifo in1
mkfifo in2
gcc select.c
./a.out
#另启窗口
echo aaa >in0
echo bbb >in1
echo ccc >in1

3.poll

poll本质上和select没有区别 , 但它没有最大连接数的限制，原因是它是基于链表来存储的。

int poll(struct pollfd *fds, int numfds, int timeout);
	struct pollfd
    {
        int fd; /* 需要监听的文件描述符 */
        short events; /* 需要监听的事件 */
        short revents; /* 已发生的事件 */
    }
	events成员描述需要监听哪些类型的事件，可以用以下几种标志来描述：
         POLLIN：文件中有数据可读，下面实例中使用到了这个标志
         POLLPRI:：文件中有紧急数据可读
         POLLOUT：可以向文件写入数据
         POLLERR：文件中出现错误，只限于输出
         POLLHUP：与文件的连接被断开了，只限于输出
         POLLNVAL：文件描述符是不合法的，即它并没有指向一个成功打开的文件
    numfds： 需要监听的文件个数，即第一个参数所指向的数组中的元素数目

	timeout ： 表示超时时间，0时立即返回，负数时则永远等待
	函数返回值, 大于0成功，等于0超时，-1表示出错。

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/select.h>
#include <sys/time.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <poll.h>
 
/* 定义缓冲区的大小 */
#define BUFFER_SIZE		512
 
/* 程序的入口函数 */
int main(int argc, char *argv[])
{
	struct pollfd fds[3];
	char buf[BUFFER_SIZE];
	int i, ret, read_len;
 
	/* 打开三个文件 */
	if((fds[0].fd = open("in0", O_RDONLY|O_NONBLOCK)) < 0)
	{
		printf("open in0 error!\n");
		return -1;
	}
	if((fds[1].fd  = open("in1", O_RDONLY|O_NONBLOCK)) < 0)
	{
		printf("open in1 error!\n");
		return -1;
	}
	if((fds[2].fd  = open("in2", O_RDONLY|O_NONBLOCK)) < 0)
	{
		printf("open in2 error!\n");
		return -1;
	}

	//memset(fds, sizeof(fds), 0);
 
	/* 初始化各文件描述符需要监听的事件 */
	for(i = 0; i < sizeof(fds)/sizeof(fds[0]); i++)
	{
		fds[i].events = POLLIN;
	}
 
	/* 进入循环操作 */
	while(1)
	{
		/*
		 *	监视三个文件的读操作，一直等待
		 *		返回值 : 0 超时 -1 出错 大于0 成功
		 */
		ret = poll(fds, sizeof(fds)/sizeof(fds[0]), -1);
 
		if(ret < 0)		/* 出错 */
		{
			printf("poll error!\n");
			return -1;
		}
		else if (ret == 0)	/* 超时 */
		{
			printf("time out!\n");
			return 0;
		}
		else if(ret > 0)	/* 成功 */
		{
			for(i = 0; i < sizeof(fds)/sizeof(fds[0]); i++)
			{
				if(fds[i].revents & POLLIN)	/* 对应文件有数据可读 */
				{
					memset(buf, 0, BUFFER_SIZE);
					read_len = read(fds[i].fd, buf, BUFFER_SIZE);
					if(read_len > 0)
					{
						buf[read_len] = '\0';
						printf("Read from in%d : %s\n", i, buf);
					}
				}
			}
		}
	}
	
	return 0;
}

4.epoll

epoll是在2.6内核中提出的，是之前的select和poll的增强版本。相对于select和poll来说，epoll更加灵活，没有描述符限制。epoll使用一个文件描述符管理多个描述符，将用户关系的文件描述符的事件存放到内核的一个事件表中，这样在用户空间和内核空间的copy只需一次。

**基本原理：**epoll支持水平触发和边缘触发，最大的特点在于边缘触发，它只告诉进程哪些fd刚刚变为就绪态，并且只会通知一次。还有一个特点是，epoll使用“事件”的就绪通知方式，通过epoll_ctl注册fd，一旦该fd就绪，内核就会采用类似callback的回调机制来激活该fd，epoll_wait便可以收到通知。

epoll的优点：

  • 没有最大并发连接的限制，能打开的FD的上限远大于1024（1G的内存上能监听约10万个端口）。
  • 效率提升，不是轮询的方式，不会随着FD数目的增加效率下降。
  • 内存拷贝，利用mmap()文件映射内存加速与内核空间的消息传递；即epoll使用mmap减少复制开销。

epoll对文件描述符的操作有两种模式：LT（level trigger）和ET（edge trigger）。LT模式是默认模式，LT模式与ET模式的区别如下：

LT模式：当epoll_wait检测到描述符事件发生并将此事件通知应用程序，应用程序可以不立即处理该事件。下次调用epoll_wait时，会再次响应应用程序并通知此事件。

ET模式：当epoll_wait检测到描述符事件发生并将此事件通知应用程序，应用程序必须立即处理该事件。如果不处理，下次调用epoll_wait时，不会再次响应应用程序并通知此事件。

int epoll_create(int size);
	自从linux2.6.8之后，size参数是被忽略的。
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
	epfd, epoll_create函数的返回值
    op, 常用宏
        EPOLL_CTL_ADD：注册新的fd到epfd中；
        EPOLL_CTL_MOD：修改已经注册的fd的监听事件；
        EPOLL_CTL_DEL：从epfd中删除一个fd；
    fd, 需要监听的文件描述符
    event, 需要监听的事件
        struct epoll_event {

               __uint32_t   events;      /* Epoll events */

               epoll_data_t data;        /* User data variable */

           };
		  EPOLLIN ：表示对应的文件描述符可以读
           EPOLLOUT：表示对应的文件描述符可以写
           EPOLLPRI：表示文件描述符有紧急的数据可读
           EPOLLERR：表示文件描述符发生错误
           EPOLLHUP：表示文件描述符被挂断
           EPOLLET： 将EPOLL设为边缘触发(Edge Triggered)模式
           EPOLLONESHOT：只监听一次事件
int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
        参数events用来从内核得到事件的集合
        参数events用来从内核得到事件的集合
        maxevents告之内核这个events有多大
        参数timeout是超时时间（

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/select.h>
#include <sys/time.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/epoll.h>
 
/* 定义缓冲区的大小 */
#define BUFFER_SIZE		512
#define MAX_EVENTS 1024

 
/* 程序的入口函数 */
int main(int argc, char *argv[])
{
	struct epoll_event event, events[MAX_EVENTS];
	char buf[BUFFER_SIZE];
	int i, ret, read_len;
	int fds[3] = {0};
	
	//创建epoll实例 内核中
	int epollfd = epoll_create(MAX_EVENTS);
	if(epollfd == -1){
		perror("epoll create");
		return -1;
	}
	

	/* 打开三个文件 */
	if((fds[0] = open("in0", O_RDONLY|O_NONBLOCK)) < 0)
	{
		printf("open in0 error!\n");
		return -1;
	}
	event.data.fd = fds[0];
	event.events = EPOLLIN;//监听读
	if(epoll_ctl(epollfd, EPOLL_CTL_ADD, event.data.fd, &event)){
		perror("epoll add error");
		return -1;
	}


	if((fds[1]  = open("in1", O_RDONLY|O_NONBLOCK)) < 0)
	{
		printf("open in1 error!\n");
		return -1;
	}
	event.data.fd = fds[1];
	event.events = EPOLLIN;//监听读
	if(epoll_ctl(epollfd, EPOLL_CTL_ADD, event.data.fd, &event)){
		perror("epoll add error");
		return -1;
	}


	if((fds[2]  = open("in2", O_RDONLY|O_NONBLOCK)) < 0)
	{
		printf("open in2 error!\n");
		return -1;
	}
	event.data.fd = fds[2];
	event.events = EPOLLIN;//监听读
	if(epoll_ctl(epollfd, EPOLL_CTL_ADD, event.data.fd, &event)){
		perror("epoll add error");
		return -1;
	}

 
	/* 进入循环操作 */
	while(1)
	{

		int nfds = epoll_wait(epollfd, events, MAX_EVENTS, -1);
		if (nfds == -1){
			perror("epoll wait");
			return -1;
		}
		int n = 0;
		for(n=0; n<nfds; n++){
			if(events[n].data.fd == fds[0]){
				memset(buf, 0, BUFFER_SIZE);
				read_len = read(fds[0], buf, BUFFER_SIZE);
				if(read_len > 0)
				{
					buf[read_len] = '\0';
					printf("Read from in0 : %s\n", buf);
				}
			}			
			if(events[n].data.fd == fds[1]){
				memset(buf, 0, BUFFER_SIZE);
				read_len = read(fds[1], buf, BUFFER_SIZE);
				if(read_len > 0)
				{
					buf[read_len] = '\0';
					printf("Read from in1 : %s\n", buf);
				}
			}			
			if(events[n].data.fd == fds[2]){
				memset(buf, 0, BUFFER_SIZE);
				read_len = read(fds[2], buf, BUFFER_SIZE);
				if(read_len > 0)
				{
					buf[read_len] = '\0';
					printf("Read from in2 : %s\n", buf);
				}
			}			
		}
	}
	return 0;
}

在选择select，poll，epoll时要根据具体的使用场合以及这三种方式的自身特点 :

  • 表面上看epoll的性能最好，但是在连接数少并且连接都十分活跃的情况下，select和poll的性能可能比epoll好，毕竟epoll的通知机制需要很多函数回调。
  • select低效是因为每次它都需要轮询。但低效也是相对的，视情况而定，也可通过良好的设计改善。

5.内核源码分析

1683868803410

SYSCALL_DEFINE1(epoll_create, int, size)
{
    if (size <= 0)
        return -EINVAL;

    return sys_epoll_create1(0);
}
SYSCALL_DEFINE1(epoll_create1, int, flags)
{
    // kzalloc(sizeof(*ep), GFP_KERNEL),用的是内核空间
    error = ep_alloc(&ep);
    // 获取尚未被使用的文件描述符，即描述符数组的槽位
    fd = get_unused_fd_flags(O_RDWR | (flags & O_CLOEXEC));
    // 在匿名inode文件系统中分配一个inode,并得到其file结构体
    // 且file->f_op = &eventpoll_fops
    // 且file->private_data = ep;
    file = anon_inode_getfile("[eventpoll]", &eventpoll_fops, ep,
                 O_RDWR | (flags & O_CLOEXEC));
    // 将file填入到对应的文件描述符数组的槽里面
    fd_install(fd,file);             
    ep->file = file;
    return fd;
}

最后epoll_create生成的文件描述符如下图所示

Linux下epoll使用源码样例分析

所有的epoll系统调用都是围绕eventpoll结构体做操作,现简要描述下其中的成员:

/*
 * 此结构体存储在file->private_data中
 */
struct eventpoll {
    // 自旋锁，在kernel内部用自旋锁加锁，就可以同时多线(进)程对此结构体进行操作
    // 主要是保护ready_list
    spinlock_t lock;
    // 这个互斥锁是为了保证在eventloop使用对应的文件描述符的时候，文件描述符不会被移除掉
    struct mutex mtx;
    // epoll_wait使用的等待队列，和进程唤醒有关
    wait_queue_head_t wq;
    // file->poll使用的等待队列，和进程唤醒有关
    wait_queue_head_t poll_wait;
    // 就绪的描述符队列
    struct list_head rdllist;
    // 通过红黑树来组织当前epoll关注的文件描述符
    struct rb_root rbr;
    // 在向用户空间传输就绪事件的时候，将同时发生事件的文件描述符链入到这个链表里面
    struct epitem *ovflist;
    // 对应的user
    struct user_struct *user;
    // 对应的文件描述符
    struct file *file;
    // 下面两个是用于环路检测的优化
    int visited;
    struct list_head visited_list_link;
};

SYSCALL_DEFINE4(epoll_wait, int, epfd, struct epoll_event __user *, events,
        int, maxevents, int, timeout)
{
    /* 检查epfd是否是epoll\_create创建的fd */
    // 调用ep_poll
    error = ep_poll(ep, events, maxevents, timeout);
    ...
}
static int ep_poll(struct eventpoll *ep, struct epoll_event __user *events,
           int maxevents, long timeout)
{
    __add_wait_queue_exclusive(&ep->wq, &wait);
    。。
}

当设备（文件）IO就绪时，在驱动程序中调用

wake_up_interruptible_sync_poll
    __wake_up_sync_key
    	__wake_up_common
    		curr->func(curr, mode, wake_flags, key) //回调ep_poll_callback{
    				list_add_tail(&epi->rdllink, &ep->rdllist);//添加到就绪队列
    				/*
                     * Wake up ( if active ) both the eventpoll wait list and the ->poll()
                     * wait list.
                     */
                    if (waitqueue_active(&ep->wq))
                        wake_up_locked(&ep->wq);
                    if (waitqueue_active(&ep->poll_wait))
                        pwake++;

			}

img

当进程调用 epoll_create 方法时，内核会创建一个 eventpoll 对象 ，这个eventpoll对象既是一个设备，也是一个进程。

说它是一个设备，是因为它有一个成员变量wait_queue_head_t wq;，设备是否就绪取决于成员变量rdllist是否为空，为空时调用epoll_wait的进程A就睡眠在wq指向的等待队列上。

请添加图片描述

说它是一个进程，是因为内核会将eventpoll管理的设备对象(epitem)添加到真正监测的设备对应的等待队列中去。

poll()
* wait list.
*/
if (waitqueue_active(&ep->wq))
wake_up_locked(&ep->wq);
if (waitqueue_active(&ep->poll_wait))
pwake++;

		}




 [外链图片转存中...(img-WbqVdbZw-1720947587083)] 





当进程调用 `epoll_create` 方法时，内核会创建一个 `eventpoll` 对象 ，**这个eventpoll对象既是一个设备，也是一个进程。**

说它是一个设备，是因为它有一个成员变量wait_queue_head_t wq;，设备是否就绪取决于成员变量rdllist是否为空，为空时调用epoll_wait的进程A就睡眠在wq指向的等待队列上。

 [外链图片转存中...(img-bKSFGO46-1720947587083)] 

说它是一个进程，是因为内核会将eventpoll管理的设备对象(epitem)添加到真正监测的设备对应的等待队列中去。
多路复用
jump_into_zehe的博客
05-22 1400
多路复用 多路复用(multiplexing),简称复用，是通信技术中的基本概念 多路复用：链路/网络资源（如带宽）划分为“资源片” * 将资源片分配给各路“呼叫”(calls) * 每路呼叫独占分配到的资源片进行通信 * 资源片可能“闲置”(idle)(无共享) 典型多路复用方法 频分多路复用（FDM） 时分多路复用（TDM） 波分多路复用（WDM） 码分多路复用（CDM） 频分多路复用FDM FDM: 将信号资源根据频率划分 频分多路复用的用户占用不同的带宽资源(这里的带宽是频率带宽（单位：Hz
IO多路复用详解
m0_52869516的博客
07-24 1488
io多路复用。文章介绍IO模型、改变读写方式、以及select和poll
多路复用.c
封雷的博客
01-02 584
#include &lt;stdio.h&gt; #include &lt;sys/types.h&gt; #include &lt;sys/socket.h&gt; #include &lt;string.h&gt; #include &lt;unistd.h&gt; #include &lt;arpa/inet.h&gt; #include &lt;stdlib.h&gt; #include
多路复用，多级页表，DMA
最新发布
weixin_49442949的博客
04-21 939
在页式存储管理中，通常会把地址空间划分成固定大小的页。例如，在进行大量数据的文件传输时，如果没有DMA，CPU需要不断地从设备读取数据并写入内存，这会占用大量的CPU时间，而使用DMA技术，CPU可以在数据传输的同时进行其他运算或处理任务。例如，一个进程只使用了虚拟地址空间中的一小部分，采用多级页表时，只需要为这部分使用到的地址建立页表，而单级页表则需要为整个虚拟地址空间建立页表，浪费了大量内存。例如，在二级页表中，需要先访问外层页表，再访问内层页表，才能得到物理地址，而单级页表只需要一次访问页表即可。
linux下的io多路复用形象化理解
ScottAci的博客
08-08 1839
这个还是很好说清楚的。 假设你是一个机场的空管， 你需要管理到你机场的所有的航线， 包括进港，出港， 有些航班需要放到停机坪等待，有些航班需要去登机口接乘客。 你会怎么做? 最简单的做法，就是你去招一大批空管员，然后每人盯一架飞机， 从进港，接客，排位，出港，航线监控，直至交接给下一个空港，全程监控。 那么问题就来了： 很快你就发现空管塔里面聚集起来一大票的
Linux I/O多路复用详解及实例
09-15
Linux I/O多路复用是一种高效的编程模型，它允许单个进程同时监视多个I/O事件，从而提高了系统的并发处理能力。在Linux中，I/O多路复用主要有三种实现方式：`select`、`poll`和`epoll`。这些机制都用于解决传统阻塞I...
网络编程—IO多路复用详解
Linuxhus的博客
08-16 1492
假如你想了解IO多路复用，那本文或许可以帮助你 本文的最大目的就是想要把select、epoll在执行过程中干了什么叙述出来，所以具体的代码不会涉及，毕竟不同语言的接口有所区别。 基础知识 IO多路复用涉及硬件、操作系统、应用程序三个层面，了解这些知识是很有帮助的。 假如已经了解，可直接跳过 Linux系统中断 中断是指计算机在执行期间，系统内发生任何非寻常的或非预期的急需处理事件，使得CPU暂时中断当前正在执行的程序而转去执行相应的事件处理程序，待处理完毕后又返回原来被中断处继续执行或调度.
Linux I/O多路复用详解：实战与应用
Linux I/O多路复用详解及实例深入剖析了在Linux操作系统中处理I/O（Input/Output）操作的一种高级技术，它允许进程同时监控多个文件描述符，而非等待每个I/O操作完全完成。Linux操作系统将各种设备抽象为文件，如...
Python IO多路复用详解：并发连接操作指南
本文将深入解析Python中的IO多路复用技术，特别是在处理大量并发连接场景下的应用。首先，让我们明确何为IO多路复用。在计算机网络编程中，当服务器需要同时处理多个客户端连接，每个连接都需要读写操作（如Socket...
多路复用（
geiii9的博客
04-12 2781
apue 多路复用
一、多路复用
怪蜀黍
03-12 3219
1.什么是多路复用 数据通信系统或计算机网络系统中，传输媒体的带宽或容量往往会大于传输单一信号的需求，为了有效地利用通信线路,希望一个信道同时传输多路信号，这就是所谓的多路复用技术(Multiplexing)。采用多路复用技术能把多个信号组合起来在一条物理信道上进行传输，在远距离传输时可大大节省电缆的安装和维护费用。频分多路复用FDM (Frequency Division Multiplexing)和时分多路复用TDM (Time Division Multiplexing)是两种最常用的多路复用技术。
【系统编程】多路复用(select、poll、epoll)
Jason的技术探索与分享
09-21 388
I/O复用函数 使用select()函数 1、这个函数会一直阻塞等待并不停监测集合里的文件描述符是否发生变化，如果发生变化就返回，不再阻塞，并且会将集合里没有发生变化的文件描述符从集合里踢出去。 缺点： 1 线程不安全，如果其他线程发现文件描述符没有在使用可能会回收 select()函数不允许，如果强制关闭，可能会发生未知错误。 2 监测的文件描述...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值