EPOLL高并发服务器

最新推荐文章于 2023-06-14 16:29:40 发布
最新推荐文章于 2023-06-14 16:29:40 发布
阅读量888 收藏 3
点赞数
CC 4.0 BY-SA版权
分类专栏： 网络相关
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/junior19/article/details/88081673

IO复用模型有select、poll、epoll，关于它们的区别：

1.select能处理的fd数量很少，我的电脑是1024个(sizeof(fd_set)*8)，而epoll的fd数量没有限制，只与内存大小有关。

2.select当fd就绪时，需要将所有fd拷贝到内核态再将活跃的fd拷贝回用户态，还有遍历fd数组判断哪个是活跃的。而epoll不需要频繁的拷贝，当fd就绪时调用回调函数插入到fd就绪链边中。

3.select是水平触发，epoll支持水平触发和边缘触发，边缘触发在调用epoll_wait时，只有fd从不可读/写到可读/写才通知给用户。而select只要fd的数据没有读完都会不断通知给用户，所以epoll读/写数据时要一次性完成（比如循环读写），否则造成fd死锁。

4.单线程多路复用应该设置nonblock套接字，否则某个客户端出现block就会影响其他fd的处理。

 

具体一点说就是：

调用select函数需要将用户buffer的fd拷贝到内核buffer进行轮询问，有事件发生又将它们拷贝回用户buffer（两个buffer都在物理内存上面）。既然都在内存上面为啥不公用一块内存呢？epoll就是这么做，mmap将地址空间的虚拟地址映射到一块物理内存，提供给用户和内核使用，减少了拷贝过程，同时那块内存用红黑树来存储fd（加速增删查改）。

服务器

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/epoll.h>
#include <unistd.h>
#include <list>
#include <fcntl.h>

#include <sys/types.h>
#define IPADDRESS "127.0.0.1"
#define PORT 8888
#define MAXSIZE 1024
#define LISTENQ 5
#define FDSIZE 1024

#define EPOLLEVENTS 100

using namespace std;
//设置非阻塞socket，IO多路复用应该用非阻塞socket
void set_nonblock(int fd);
//添加、删除、修改事件到epoll
void do_event(int epollfd, int fd, int op, int state);
bool Read(int epollfd, int fd, char *buff, int size);
bool Send(int epollfd, int fd, char *buff);

list<int>all_fd;
int main()  {
    char buff[MAXSIZE];
    char WARN[] = "just you online, honey.\n";
    int listenfd = socket(AF_INET, SOCK_STREAM, 0);
    if(listenfd == -1){
        perror("socket error:");
        exit(1);
    }
    else puts("create socket done.");
    struct sockaddr_in servaddr;
    servaddr.sin_addr.s_addr = inet_addr(IPADDRESS);
    servaddr.sin_port = htons(PORT);
    servaddr.sin_family = AF_INET;
    if(bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1){
        perror("bind error:");
        exit(1);
    }
    else puts("bind done.");
    listen(listenfd, LISTENQ);
    puts("listen done");
    struct epoll_event events[EPOLLEVENTS];

    int epollfd = epoll_create(FDSIZE);
    do_event(epollfd, listenfd, EPOLL_CTL_ADD, EPOLLIN | EPOLLET);
    set_nonblock(listenfd);
    while(true){
        int num = epoll_wait(epollfd, events, EPOLLEVENTS, -1);//阻塞epoll_wait
        for(int i=0; i<num; ++i){
            int fd = events[i].data.fd;
            if(fd == listenfd){
                printf("epolled get a new\n");
                struct sockaddr_in cliaddr;
                socklen_t cliaddrlen = sizeof(struct sockaddr_in);
                int clifd = accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddrlen);
                if(clifd == -1){
                    perror("accept error");
                    continue;
                }
                set_nonblock(clifd);
                printf("accept a new client: %s %d, welcome!\n",inet_ntoa(cliaddr.sin_addr), ntohs(cliaddr.sin_port));
                do_event(epollfd, clifd, EPOLL_CTL_ADD, EPOLLIN | EPOLLET);
                all_fd.push_back(clifd);
            }
            else{
                if(Read(epollfd, fd, buff, MAXSIZE)){
                    printf("success to read. %s %d\n",buff,all_fd.size());
                    if(all_fd.size() == 1){
                        Send(epollfd, fd, WARN);
                    }
                    else{
                        for(auto it=all_fd.begin(); it!=all_fd.end(); ++it){
                            int tfd = *it;
                            if(tfd != fd){
                                if(!Send(epollfd, tfd, buff)){
                                    *it = -1;
                                }
                            }
                        }
                        all_fd.remove(-1);
                    }
                }
                else{
                    perror("server read message fail.");
                    continue;
                }
            }
        }
    }
    close(epollfd);
    close(listenfd);
    return 0;
}

void set_nonblock(int fd){
    fcntl(fd, F_SETFL, fcntl(fd, F_GETFL)|O_NONBLOCK);
}
void do_event(int epollfd, int fd, int op, int state){
    struct epoll_event ev;
    ev.data.fd = fd;
    ev.events = state;
    epoll_ctl(epollfd, op, fd, &ev);
}
bool Read(int epollfd, int fd, char *buff, int size){
    memset(buff, 0, MAXSIZE);
    int num;
    do{
        num = recv(fd, buff, size, 0);
        if(num < 0){
            if(errno == EAGAIN){
                return true;
            }
            else{
                perror("read error:");
                close(fd);
                do_event(epollfd, fd, EPOLL_CTL_DEL, EPOLLIN);
                return false;
            }
        }
        else{
            size -= num;
            buff += num;
        }
    }while(num > 0);

    printf("read done %s\n",buff);
    return true;
}
bool Send(int epollfd, int fd, char *buff){
    int size = strlen(buff);
    while(size > 0){
        int num = send(fd, buff, size, 0);
        if(num < 0){
            perror("send error:");
            close(fd);
            do_event(epollfd, fd, EPOLL_CTL_DEL, EPOLLIN);
            return false;
        }
        else{
            size -= num;
            buff += num;
        }
    }
    printf("perfect send\n");
    return true;
}

客户端（或者直接TELNET连服务器）

客户端参考https://blog.csdn.net/qq_31564375/article/details/51581038的思路，开个子进程，父子进程管道相连，子进程负责写数据，父进程负责读数据和服务器通信。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/epoll.h>
#include <unistd.h>
#include <list>
#include <fcntl.h>
#include <sys/types.h>
#define IPADDRESS "127.0.0.1"
#define PORT 8888
#define MAXSIZE 1024
#define LISTENQ 5
#define FDSIZE 1024
#define EPOLLEVENTS 100

using namespace std;
//设置非阻塞socket，IO多路复用应该用非阻塞socket
void set_nonblock(int fd);
//添加、删除、修改事件到epoll
void do_event(int epollfd, int fd, int op, int state);
bool Read(int epollfd, int fd, char *buff, int size);
bool Send(int epollfd, int fd, char *buff);

int main(){
    struct epoll_event events[3];
    struct sockaddr_in servaddr;
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = inet_addr(IPADDRESS);
    servaddr.sin_port = htons(PORT);

    int serfd = socket(AF_INET, SOCK_STREAM, 0);
    if(serfd == -1){
        perror("socket create fail.\n");
        exit(-1);
    }
    else puts("socket create done.");
    if(connect(serfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0){
        perror("connect fail.\n");
        exit(-1);
    }
    else puts("connect done.");

    set_nonblock(serfd);
    int pip_fd[2];
    if(pipe(pip_fd) < 0){
        perror("pipe error.");
        exit(-1);
    }
    else puts("pipe done.");
    int epollfd = epoll_create(FDSIZE);
    do_event(epollfd, serfd, EPOLL_CTL_ADD, EPOLLIN | EPOLLET);
    do_event(epollfd, pip_fd[0], EPOLL_CTL_ADD, EPOLLIN | EPOLLET);
    bool cliworking = true;

    int pid = fork();
    if(pid < 0){
        perror("fork error.");
        exit(-1);
    }
    else if(pid == 0){
        close(pip_fd[0]);
        printf("print exit to leave.\n");
        while(cliworking){
            char buff[MAXSIZE]={0};
            scanf("%s",buff);
            if(strncmp("exit", buff, 4) == 0) cliworking = 0;
            write(pip_fd[1], buff, strlen(buff));
        }
        close(serfd);
        close(pip_fd[1]);
        close(epollfd);
        exit(0);
    }
    else{
        close(pip_fd[1]);
        while(cliworking){
            int num = epoll_wait(epollfd, events, 2, -1);
            for(int i=0; i<num; ++i){
                int fd = events[i].data.fd;
                if(fd == serfd){
                    char buff[MAXSIZE]={0};
                    if(Read(epollfd, fd, buff, MAXSIZE)){
                        printf("%s\n",buff);
                    }
                    else{
                        perror("server unconnect.");
                        cliworking = 0;
                    }
                }
                else{
                    char buff[MAXSIZE]={0};
                    read(fd, buff, MAXSIZE);
                    if(strncmp("exit", buff, 4) == 0){
                        printf("here\n");
                        cliworking = 0;
                    }
                    else if(!Send(epollfd, serfd, buff)){
                        perror("send error.");
                    }
                }
            }
        }
        close(pip_fd[0]);
        close(serfd);
        close(epollfd);
        exit(0);
    }
    return 0;

}

void set_nonblock(int fd){
    fcntl(fd, F_SETFL, fcntl(fd, F_GETFL)|O_NONBLOCK);
}
void do_event(int epollfd, int fd, int op, int state){
    struct epoll_event ev;
    ev.data.fd = fd;
    ev.events = state;
    epoll_ctl(epollfd, op, fd, &ev);
}
bool Read(int epollfd, int fd, char *buff, int size){
    memset(buff, 0, MAXSIZE);
    int num;
    do{
        num = recv(fd, buff, size, 0);
        if(num < 0){
            if(errno == EAGAIN){
                return true;
            }
            else{
                perror("read error:");
                close(fd);
                do_event(epollfd, fd, EPOLL_CTL_DEL, EPOLLIN);
                return false;
            }
        }
        else{
            size -= num;
            buff += num;
        }
    }while(num > 0);
    return true;
}
bool Send(int epollfd, int fd, char *buff){
    int size = strlen(buff);
    while(size > 0){
        int num = send(fd, buff, size, 0);
        if(num < 0){
            perror("send error:");
            close(fd);
            do_event(epollfd, fd, EPOLL_CTL_DEL, EPOLLIN);
            return false;
        }
        else{
            size -= num;
            buff += num;
        }
    }
    return true;
}

 

Linux高并发服务器——epoll服务器
赵小厨的博客
08-19 966
epoll服务器 一、概述 epoll是Linux下多路复用IO接口select/poll的增强版本 epoll能显著提高程序在大量并发连接中只有少量活跃的情况下的系统CPU利用率 select使用轮询来处理，随着监听 fd 数目的增加而降低效率。而epoll只需要监听那些已经准备好的队列集合中的文件描述符，效率较高。 二、epoll API 头文件 #include <sys/epol...
Linux + C + Epoll实现高并发服务器(线程池 + 数据库连接池)
09-27
在Linux 系统下面用C 语言实现的高并发服务器的代码，具体用到了Epoll，线程池，数据库连接池。 具体可以看下连接http://blog.csdn.net/wuyuxing24/article/details/48758927
epoll高并发服务器
qq_24093081的博客
03-18 1133
epoll高并发原理： 把需要监听的文件描述符写进集合里，当某个文件描述符有信息时会自动冒出来，不像select那样不断查找是哪个 文件描述符，所以效率会较高 高并发服务器设计: 相关函数： 1.int epoll_create(int size);作用：实例化一个epoll对象，返回值为epfd 参数表示监听多少个文件描述符 2. int epoll_wait(int epfd, struct epoll_event *events,int maxevents, int
epoll实现并发服务器
JiaYu的博客
06-14 1591
它采用了一种基于事件的工作方式，当文件描述符上有事件发生时，内核会通知应用程序，并将发生的事件放入一个事件列表中，应用程序可以通过读取该列表来获取已就绪的事件。的具体使用方式还取决于应用程序的需求和设计，上述示例代码只是一种基本的演示，实际应用中可能需要根据具体情况进行更详细和复杂的处理。的优势在于它能够高效处理大量的并发连接，并且对于大规模的并发应用程序来说，比传统的事件通知机制具有更好的性能。：等待就绪事件的发生，阻塞直到有事件发生，然后将就绪的事件填充到指定的事件列表中，返回就绪事件的数量。
epoll 版 高并发服务器
weixin_42374938的博客
08-13 171
#include <stdio.h> #include <unistd.h> #include <stdlib.h> #include <string.h> #include <arpa/inet.h> #include <sys/epoll.h> #include <errno.h> #include <ctype.h> int main() { // 1 创建套接字 int lfd = socket(AF
epoll并发服务器
松狮
08-08 1020
1、基本模型 （1）多进程并发服务器：http://blog.csdn.net/songshimvp1/article/details/51819765 （2）多线程并发服务器：http://blog.csdn.net/songshimvp1/article/details/51895311 （3）I/O服用并发服务器：select、poll 2、epoll服务器 （1）epoll_
基于Linux和C语言的Epoll高并发服务器技术
在Linux系统中使用C语言结合Epoll实现高并发服务器是一项涉及多技术领域的复杂任务，本内容将详细解读Linux、C语言、Epoll以及线程池和数据库连接池的实现及其在高并发服务器中的应用。 ### Linux操作系统 Linux...
【Linux服务器开发】基于epoll的高并发服务器设计与实现：IO复用技术在Linux系统中的应用
最新发布
06-24
首先解释了IO复用的概念及其与多线程的区别，强调了epoll在高并发服务器中的重要性。接着深入探讨了epoll的工作机制，包括创建epoll实例、添加和管理事件、处理事件的具体流程，特别是LT（水平触发）和ET（边缘触发...
Linux下基于epoll 线程池高并发服务器实现研究.pdf
09-06
Linux下基于epoll线程池高并发服务器实现研究 本文研究了Linux操作系统下基于epoll机制和线程池技术的高并发服务器实现。高并发服务器在当前数字化、网络化和信息化的时代中变得越来越重要，因为服务器的并发请求量...
epoll 的并发服务器
12-08
在Linux操作系统中，`epoll`是用于处理高并发I/O事件的一种高效机制，尤其适合于网络服务器。它是在早期的`poll`和`select`系统调用基础上发展起来的，旨在解决它们在处理大量并发连接时性能下降的问题。本篇将深入...
epoll多线程高并发服务器代码
09-22
linux下完整的epoll多线程高并发服务器代码
Linux下基于epoll_线程池高并发服务器实现研究
06-01
Linux下基于epoll_线程池高并发服务器实现研究，研究Linux的人可以看看。
epoll+消息队列-通过使用pthread_cond_signal的一个简单实现
你我皆凡人，生在人世间
06-27 555
第一次用epoll去实现一个服务器, 之前并不清楚epoll的用法, 了解之后才发现epoll服务器的主线程其实最好和处理业务的代码分开, 也就是说: epoll响应外界的io请求,当epoll得到一个请求的时候,扔到一个消息队列中,然后epoll直接返回,再去等待io请求.而消息队列会通知多个线程去处理这些业务逻辑. epoll第一次用,消息队列更是第一次用,开始一直在想,怎么写个...
epoll编程，如何实现高并发服务器开发？
波波诸葛伟
10-27 1985
转载地址:https://www.zhihu.com/question/21516827 1、本系统处理的业务为多客户端接入，一旦接入基本超过8个小时的长连接，但是登陆以后客户端基本不怎么活动，只有客户端触发相关设定事件才会产生活跃通信。 2、查了很多资料，单单多进程是不现实的，但是多线程开发linux系统在线程的数量上是有上限的，如何解决？ 3、QQ、SKYPE等的多客户端登陆
高并发服务器epoll
wuyou的博客
04-25 1191
epoll 多路IO
epoll高并发多路复用,基于epoll的高性能服务器
weixin_34018169的博客
07-17 171
并发测试工具ab使用linux命令安装这个工具:apt-get install apache2windows中装好apache之后就会再带一个工具windows命令使用方法ab -n 200 -c 5 http://www.baidu.com/1000就是测试的数量-c 10 就是开启的线程数测试的地址反回了一些测试信息,如 使用时间,每次要多久...
3高并发服务器：多路IO之epoll
涂作权的博客
09-30 2078
 1 epoll epoll是Linux下多路复用IO接口select/poll的增强版本，它能显著提高程序在大量并、发连接中只有少量活跃的情况下的系统CPU利用率，因为它会复用文件描述符集合来传递结果而不用迫使开发者每次等待事件之前都必须重新准备要被侦听的文件描述符集合，另一点原因就是获取事件的时候，它无须遍历整个被侦听的描述符集，只要遍历那些被内核IO事件异步唤醒而加入Read
Epoll实现服务器高并发
清水
10-07 1240
最近在做一个
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值