epoll简单实现C/S模型----多路IO转接之高并发

最新推荐文章于 2024-05-21 20:56:54 发布

coison_z

最新推荐文章于 2024-05-21 20:56:54 发布

阅读量77

点赞数

分类专栏： Linux网络编程文章标签： c语言 linux 开发语言网络 tcp/ip

本文链接：https://blog.csdn.net/blank_koko/article/details/129822792

版权

Linux网络编程专栏收录该内容

5 篇文章 0 订阅

订阅专栏

epoll简介

epoll是Linux下多路复用IO接口select/poll的增强版本，它能显著提高程序在大量并发连接中只有少量活跃的情况下的系统CPU利用率，因为它会复用文件描述符集合来传递结果而不用迫使开发者每次等待事件之前都必须重新准备要被侦听的文件描述符集合，另一点原因就是获取事件的时候，它无须遍历整个被侦听的描述符集，只要遍历那些被内核IO事件异步唤醒而加入Ready队列的描述符集合就行了。
epoll除了提供select/poll那种IO事件的电平触发（Level Triggered）外，还提供了边沿触发（Edge Triggered），这就使得用户空间程序有可能缓存IO状态，减少epoll_wait/epoll_pwait的调用，提高应用程序效率。

可以使用cat命令查看一个进程可以打开的socket描述符上限。
cat /proc/sys/fs/file-max
如有需要，可以通过修改配置文件的方式修改该上限值。
sudo vi /etc/security/limits.conf
在文件尾部写入以下配置,soft软限制，hard硬限制。如下图所示。

* soft nofile 65536
* hard nofile 100000

epoll相关函数

创建一个epoll句柄，参数size用来告诉内核监听的文件描述符的个数，跟内存大小有关。

	#include <sys/epoll.h>
	int epoll_create(int size)		size：监听数目
	
	返回 ：
		Epoll的文件描述符
		-1表示出错

控制某个epoll监控的文件描述符上的事件：注册、修改、删除。

#include <sys/epoll.h>
	int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)
		epfd：	为epoll_creat的句柄
		op：		表示动作，用3个宏来表示：
			EPOLL_CTL_ADD (注册新的fd到epfd)，
			EPOLL_CTL_MOD (修改已经注册的fd的监听事件)，
			EPOLL_CTL_DEL (从epfd删除一个fd)；
		event：	告诉内核需要监听的事件

		struct epoll_event {
			__uint32_t events; /* Epoll events */
			epoll_data_t data; /* User data variable */
		};
		typedef union epoll_data {
			void *ptr;
			int fd;
			uint32_t u32;
			uint64_t u64;
		} epoll_data_t;

		EPOLLIN ：	表示对应的文件描述符可以读（包括对端SOCKET正常关闭）
		EPOLLOUT：	表示对应的文件描述符可以写
		EPOLLPRI：	表示对应的文件描述符有紧急的数据可读（这里应该表示有带外数据到来）
		EPOLLERR：	表示对应的文件描述符发生错误
		EPOLLHUP：	表示对应的文件描述符被挂断；
		EPOLLET： 	将EPOLL设为边缘触发(Edge Triggered)模式，这是相对于水平触发(Level Triggered)而言的
		EPOLLONESHOT：只监听一次事件，当监听完这次事件之后，如果还需要继续监听这个socket的话，需要再次把这个socket加入到EPOLL队列里

等待所监控文件描述符上有事件的产生，类似于select()调用。

#include <sys/epoll.h>
	int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout)
		events：		用来存内核得到事件的集合，
		maxevents：	告之内核这个events有多大，这个maxevents的值不能大于创建epoll_create()时的size
		timeout：	是超时时间
			-1：	阻塞
			0：	立即返回，非阻塞
			>0：	指定毫秒
		返回值：	成功返回有多少文件描述符就绪，时间到时返回0，出错返回-1

C/S模型实现代码

服务器

#include "wrap.h"                                                                                                                                                                                                                                                                                                                           
#include <sys/types.h>
#include <sys/time.h>
#include <ctype.h>
#include <sys/epoll.h>
#define SERV_PORT 9527
#define OPEN_MAX 1024
int main()
{
    int listenfd, connfd;   //设置监听socket，传输sokcet
    int num = 0;    //客户端连接数量
    char buf[128];  

    //socket地址结构
    struct sockaddr_in serv_addr, clie_addr;
    //初始化
    bzero(&serv_addr, sizeof(serv_addr));
    bzero(&clie_addr, sizeof(clie_addr));
    socklen_t clie_addr_len = sizeof(clie_addr);

    listenfd = Socket(AF_INET, SOCK_STREAM, 0); 

    //重复利用端口号
    int opt = 1;
    setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(SERV_PORT);
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);

    //绑定监听
    Bind(listenfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr));

    //设置监听上限
    Listen(listenfd, 128);
    
    struct epoll_event tempEp, epEvents[OPEN_MAX];
    tempEp.events = EPOLLIN;  //初始化
    tempEp.data.fd = listenfd;

    //创建epoll， 设置监听数量
    int epfd = epoll_create(OPEN_MAX);
    if(-1 == epfd)
    {   
        perr_exit("epoll_create failed..\n");
    }   
    //把listenfd加入红黑树
    int ret = epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &tempEp);
    if(-1 == ret)
    {   
        perr_exit("epoll_ctl failed..\n");
    }   
    
    int maxEvents = 1;  
    while(1)
    {   
        int numsReady = epoll_wait(epfd, epEvents, maxEvents, -1);
        if(-1 == numsReady)
        {   
            perr_exit("epoll_wait failed..\n");
        }   

        for(int i = 0; i < numsReady; i++)
        {   
            if(!(epEvents[i].events & EPOLLIN))
                continue;
            if(epEvents[i].data.fd == listenfd)
            {   
                connfd = Accept(listenfd, (struct sockaddr*)&clie_addr, &clie_addr_len);

                char str[1024];
    
                printf("received from %s at PORT %d\n", inet_ntop(AF_INET, &clie_addr.sin_addr, str,  sizeof(str)),
                    ntohs(clie_addr.sin_port));
                printf("cfd %d----client %d\n", connfd, ++num);

                tempEp.events = EPOLLIN;
                tempEp.data.fd = connfd;

                //把新连接加入到 epoll红黑树                                                                                                                                                                                                                                                                                                
                ret = epoll_ctl(epfd, EPOLL_CTL_ADD, connfd, &tempEp);
                if(-1 == ret)
                    perr_exit("epoll_ctl error..\n");

            }
            else
            {
                int sockfd = epEvents[i].data.fd;
                int readNums = Read(sockfd, buf, sizeof(buf));
                if(0 == readNums || 1 == readNums)
                {
                    //摘除节点
                    ret = epoll_ctl(epfd, EPOLL_CTL_DEL, sockfd, NULL);
                    if(-1 == ret)
                        perr_exit("epoll_ctl error\n");
                    Close(sockfd);
                    printf("client[%d] closed connection\n", sockfd);

                }
                else
                {
                    for(int j = 0; j < readNums; j++)
                    {
                        buf[j] = toupper(buf[j]);
                    }
                    Write(STDOUT_FILENO, buf, readNums);
                    Write(sockfd, buf, readNums);
                }

            }
        }

    }
    close(listenfd);


    return 0;
}

客户端

#include <stdio.h>                                                                                                                                                                                                                                                                                                                          
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <errno.h>

int main()
{
    int sockFd = socket(AF_INET, SOCK_STREAM, 0); 
    if(-1 == sockFd)
    {   
        perror("socket error\n");
        exit(0);
    }   
    struct sockaddr_in serv_addr;
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(9527);
    inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr.s_addr);
    int cfd = connect(sockFd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));
    if(-1 == cfd)
    {   
        perror("connect error\n");
        exit(0);
    }   
    int loop = 5;
    char buf[1024];
    while(loop--)
    {   
        int ret = read(STDIN_FILENO, buf, sizeof(buf));
        write(sockFd, buf, ret);        //写数据到服务端
        ret = read(sockFd, buf, sizeof(buf));   //从服务端读取数据
        write(STDOUT_FILENO, buf, ret);         //数据打印
        //sleep(1);
    }   
    close(sockFd);
    return 0;
}

coison_z

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
epoll简单实现C/S模型----多路IO转接之高并发

epoll是Linux下多路复用IO接口select/poll的增强版本，它能显著提高程序在大量并发连接中只有少量活跃的情况下的系统CPU利用率，因为它会复用文件描述符集合来传递结果而不用迫使开发者每次等待事件之前都必须重新准备要被侦听的文件描述符集合，另一点原因就是获取事件的时候，它无须遍历整个被侦听的描述符集，只要遍历那些被内核IO事件异步唤醒而加入Ready队列的描述符集合就行了。
复制链接

扫一扫