EpollEpoll - IO多路复用怎么理解

75 阅读 0 评论 50 点赞

我是靠谱客的博主慈祥冰淇淋，最近开发中收集的这篇文章主要介绍EpollEpoll - IO多路复用怎么理解，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

Epoll - IO多路复用

怎么理解

在这里插入图片描述

类比快递员寄快递，传统方式是快递员挨家挨户上楼敲门现，在改为用快递柜子的方式，比如丰巢类似，现在这里有两个集合。
1.住户所有人是一个集合。
2.丰巢是一个子集，比如今天要寄快递的住户。
epoll就是管理这两个集合。
epoll_create相当于一栋楼，聘请了一个快递员，创建一栋楼
epoll_ctl往楼里搬住户，它具备三个功能：
1.是往这栋楼搬一个住户进来。
2.一个用户搬出来。
3.比如一个用户从7楼搬到8楼
分别对应下面三种，增删改。
epoll_ctl(ADD,DEL,MOD)
epoll_wiat是快递员多久来丰巢取一次快递

创建Epoll

int epoll_create(int size);

参数:
size:只要大于0即可,如果传一个<=0是不可用的
实际上,这里你传1或者10000区别是不大的,那为什么还需要这个参数呢?
早先版本的epoll他的队列大小是用size来定义的,也就是"“快递柜”"的大小,而后来不使用此参数的原因是其改为了链表存储(动态),保留此参数是为了保证代码的兼容.

创建完后还要准备一个东西 ----- epoll_event
这就好比快递员从快递柜拿快递走,不可能整个快递柜都搬走,这里就类比成一个袋子,或者一个小推车,用来装快递柜里的快递,这个我们就要定义大小了

struct epoll_event event[设置大小POLL_SIZE] = {0};
//多大合适的问题?
//假设快递柜有50个格子,你的推车只能装10个,那么跑5趟即可.
//这里只是跑的次数多少而已,对数量没有要求,设置的大,跑的次数少,设置的小,跑的次数多
//而且这个小车大小是可变的,初始不要设置太小

结构原型

struct epoll_event{
	__uint32_t  events;
	epoll_data_t data;
}

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

向EPOLL对象中添加、修改或者删除感兴趣的事件

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event); 
op取值：EPOLL_CTL_ADD        添加新的事件到epoll中
       EPOLL_CTL_MOD       修改EPOLL中的事件   
       EPOLL_CTL_DEL          删除epoll中的事件

events取值：
       EPOLLIN   表示有数据可以读出(接受连接、关闭连接)
       EPOLLOUT  表示连接可以写入数据发送（向服务器发起连接，连接成功事件）
       EPOLLERR  表示对应的连接发生错误
	   EPOLLHUP  表示对应的连接被挂起

示例片段:

struct epoll_event ev;

ev.events = EPOLLIN;
ev.data.fd = linstenfd;

epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &ev);

收集在epoll监控的事件中已经发生的事件

快递员去快递柜取出快递

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

epfd： epoll的描述符。

events：分配好的 epoll_event结构体数组，epoll将会把发生的事件复制到 events数组中
（events不可以是空指针，内核只负责把数据复制到这个 events数组中，不会去帮助我们在用户态中分配内存。内核这种做法效率很高）。

maxevents： 本次可以返回的最大事件数目，通常 maxevents参数与预分配的events数组的大小是相等的。

timeout： 表示在没有检测到事件发生时最多等待的时间（单位为毫秒），
			如果timeout为0，立刻返回，不会等待。-1表示无限期阻塞

示例片段:

while(1)
{
	int nready = epoll_wait(epfd, events, POLL_SIZE, 5);
	//POLL_SIZE小车能装多少快递, 5毫秒去一趟
	//nready返回事件个数
	if(nready == -1)continue;
}

完整代码

#include <errno.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>

#include <sys/poll.h>
#include <sys/epoll.h>


#include <pthread.h>
 
#define MAXLNE  4096

#define POLL_SIZE	1024

//8m * 4G = 128 , 512
//C10k
void *client_routine(void *arg) { //

	int connfd = *(int *)arg;

	char buff[MAXLNE];

	while (1) {

		int n = recv(connfd, buff, MAXLNE, 0);
        if (n > 0) {
            buff[n] = '';
            printf("recv msg from client: %sn", buff);

	    	send(connfd, buff, n, 0);
        } else if (n == 0) {
            close(connfd);
			break;
        }

	}

	return NULL;
}


int main(int argc, char **argv) 
{
    int listenfd, connfd, n;
    struct sockaddr_in servaddr;
    char buff[MAXLNE];
 
    if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
        printf("create socket error: %s(errno: %d)n", strerror(errno), errno);
        return 0;
    }
 
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(9999);
 
    if (bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1) {
        printf("bind socket error: %s(errno: %d)n", strerror(errno), errno);
        return 0;
    }
 
    if (listen(listenfd, 10) == -1) {
        printf("listen socket error: %s(errno: %d)n", strerror(errno), errno);
        return 0;
    }
 #if 0
    struct sockaddr_in client;
    socklen_t len = sizeof(client);
    if ((connfd = accept(listenfd, (struct sockaddr *)&client, &len)) == -1) {
        printf("accept socket error: %s(errno: %d)n", strerror(errno), errno);
        return 0;
    }

    printf("========waiting for client's request========n");
    while (1) {

        n = recv(connfd, buff, MAXLNE, 0);
        if (n > 0) {
            buff[n] = '';
            printf("recv msg from client: %sn", buff);

	    	send(connfd, buff, n, 0);
        } else if (n == 0) {
            close(connfd);
        }
        
        //close(connfd);
    }

#elif 0


    printf("========waiting for client's request========n");
    while (1) {

		struct sockaddr_in client;
	    socklen_t len = sizeof(client);
	    if ((connfd = accept(listenfd, (struct sockaddr *)&client, &len)) == -1) {
	        printf("accept socket error: %s(errno: %d)n", strerror(errno), errno);
	        return 0;
	    }

        n = recv(connfd, buff, MAXLNE, 0);
        if (n > 0) {
            buff[n] = '';
            printf("recv msg from client: %sn", buff);

	    	send(connfd, buff, n, 0);
        } else if (n == 0) {
            close(connfd);
        }
        
        //close(connfd);
    }

#elif 0

	while (1) {

		struct sockaddr_in client;
	    socklen_t len = sizeof(client);
	    if ((connfd = accept(listenfd, (struct sockaddr *)&client, &len)) == -1) {
	        printf("accept socket error: %s(errno: %d)n", strerror(errno), errno);
	        return 0;
	    }

		pthread_t threadid;
		pthread_create(&threadid, NULL, client_routine, (void*)&connfd);

    }

#elif 0

	// 
	fd_set rfds, rset, wfds, wset;

	FD_ZERO(&rfds);
	FD_SET(listenfd, &rfds);

	FD_ZERO(&wfds);

	int max_fd = listenfd;

	while (1) {

		rset = rfds;
		wset = wfds;

		int nready = select(max_fd+1, &rset, &wset, NULL, NULL);


		if (FD_ISSET(listenfd, &rset)) { //

			struct sockaddr_in client;
		    socklen_t len = sizeof(client);
		    if ((connfd = accept(listenfd, (struct sockaddr *)&client, &len)) == -1) {
		        printf("accept socket error: %s(errno: %d)n", strerror(errno), errno);
		        return 0;
		    }

			FD_SET(connfd, &rfds);

			if (connfd > max_fd) max_fd = connfd;

			if (--nready == 0) continue;

		}

		int i = 0;
		for (i = listenfd+1;i <= max_fd;i ++) {

			if (FD_ISSET(i, &rset)) { // 

				n = recv(i, buff, MAXLNE, 0);
		        if (n > 0) {
		            buff[n] = '';
		            printf("recv msg from client: %sn", buff);

					FD_SET(i, &wfds);

					//reactor
					//send(i, buff, n, 0);
		        } else if (n == 0) { //

					FD_CLR(i, &rfds);
					//printf("disconnectn");
		            close(i);
					
		        }
				if (--nready == 0) break;
			} else if (FD_ISSET(i, &wset)) {

				send(i, buff, n, 0);
				FD_SET(i, &rfds);
			
			}

		}
		

	}

#elif 0


	struct pollfd fds[POLL_SIZE] = {0};
	fds[0].fd = listenfd;
	fds[0].events = POLLIN;

	int max_fd = listenfd;
	int i = 0;
	for (i = 1;i < POLL_SIZE;i ++) {
		fds[i].fd = -1;
	}

	while (1) {

		int nready = poll(fds, max_fd+1, -1);

	
		if (fds[0].revents & POLLIN) {

			struct sockaddr_in client;
		    socklen_t len = sizeof(client);
		    if ((connfd = accept(listenfd, (struct sockaddr *)&client, &len)) == -1) {
		        printf("accept socket error: %s(errno: %d)n", strerror(errno), errno);
		        return 0;
		    }

			printf("accept n");
			fds[connfd].fd = connfd;
			fds[connfd].events = POLLIN;

			if (connfd > max_fd) max_fd = connfd;

			if (--nready == 0) continue;
		}

		//int i = 0;
		for (i = listenfd+1;i <= max_fd;i ++)  {

			if (fds[i].revents & POLLIN) {
				
				n = recv(i, buff, MAXLNE, 0);
		        if (n > 0) {
		            buff[n] = '';
		            printf("recv msg from client: %sn", buff);

					send(i, buff, n, 0);
		        } else if (n == 0) { //

					fds[i].fd = -1;

		            close(i);
					
		        }
				if (--nready == 0) break;

			}

		}

	}

#else

	//poll/select --> 
	// epoll_create 
	// epoll_ctl(ADD, DEL, MOD)
	// epoll_wait

	int epfd = epoll_create(1); //int size

	struct epoll_event events[POLL_SIZE] = {0};
	struct epoll_event ev;

	ev.events = EPOLLIN;
	ev.data.fd = listenfd;

	epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &ev);

	while (1) {

		int nready = epoll_wait(epfd, events, POLL_SIZE, 5);
		if (nready == -1) {
			continue;
		}

		int i = 0;
		for (i = 0;i < nready;i ++) {

			int clientfd =  events[i].data.fd;
			if (clientfd == listenfd) {

				struct sockaddr_in client;
			    socklen_t len = sizeof(client);
			    if ((connfd = accept(listenfd, (struct sockaddr *)&client, &len)) == -1) {
			        printf("accept socket error: %s(errno: %d)n", strerror(errno), errno);
			        return 0;
			    }

				printf("acceptn");
				ev.events = EPOLLIN;
				ev.data.fd = connfd;
				epoll_ctl(epfd, EPOLL_CTL_ADD, connfd, &ev);

			} else if (events[i].events & EPOLLIN) {

				printf("recvn");
				n = recv(clientfd, buff, MAXLNE, 0);
		        if (n > 0) {
		            buff[n] = '';
		            printf("recv msg from client: %sn", buff);

					send(clientfd, buff, n, 0);
		        } else if (n == 0) { //


					ev.events = EPOLLIN;
					ev.data.fd = clientfd;

					epoll_ctl(epfd, EPOLL_CTL_DEL, clientfd, &ev);

		            close(clientfd);
					
		        }

			}

		}

	}
	

#endif
 
    close(listenfd);
    return 0;
}

最后

以上就是慈祥冰淇淋为你收集整理的EpollEpoll - IO多路复用怎么理解的全部内容，希望文章能够帮你解决EpollEpoll - IO多路复用怎么理解所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。

本文分类：Linux服务器开发
浏览次数：75 次浏览
发布日期：2023-07-13 09:20:01
本文链接：https://www.kaopuke.com/article/k-p-k_14_uzo_22_fx_13__7_gx.html

EpollEpoll - IO多路复用怎么理解

概述

目录

Epoll - IO多路复用

怎么理解

创建Epoll

向EPOLL对象中添加、修改或者删除感兴趣的事件

收集在epoll监控的事件中已经发生的事件

完整代码

最后

评论列表共有 0 条评论

发表评论取消回复

EpollEpoll - IO多路复用怎么理解

概述

目录

Epoll - IO多路复用

怎么理解

创建Epoll

向EPOLL对象中添加、修改或者删除感兴趣的事件

收集在epoll监控的事件中已经发生的事件

完整代码

最后

相关文章

评论列表共有 0 条评论

发表评论 取消回复

发表评论取消回复