epoll实践

最新推荐文章于 2023-11-09 16:29:03 发布
最新推荐文章于 2023-11-09 16:29:03 发布
阅读量825 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： c c++ linux unix 文章标签： struct null events socket stream 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/cxxmaker/article/details/7645026

代码做的是回射服务


客户端：

#include <errno.h>
#include <netdb.h>
#include <unistd.h>
#include <cstdio>
#include <cstdlib>
#include <cstring>

const int BUFFSIZ = 4096;

int connect(const char * host, const char * serv)
{
    int               connfd;
    int               n;
    struct addrinfo   hints;
    struct addrinfo * res;
    struct addrinfo * ressave;

    memset(&hints, 0, sizeof(hints));
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;

    if (0 != (n = getaddrinfo(host, serv, &hints, &res))) {
        printf("getaddrinfo error for %s, %s: %s\n", 
               (NULL == host) ? "(no hostname)" : host, 
               (NULL == serv) ? "(no servname)" : serv, 
               gai_strerror(n));
        exit(1);
    }
    ressave = res;

    while (NULL != res) {
        connfd = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
        if (-1 != connfd) {
            if (0 == ::connect(connfd, res->ai_addr, res->ai_addrlen)) {
                break;
            }
            else {
                close(connfd);
            }
        }
        res = res->ai_next;
    }

    freeaddrinfo(ressave);

    if (NULL == res) {
        printf("connect failed\n");
        exit(1);
    }

    return(connfd);
}

int main(int argc, char ** argv)
{
    if (3 != argc) {
        printf("usage: %s <host> <serv>\n", argv[0]);
        exit(1);
    }

    int connfd = connect(argv[1], argv[2]);

    char buff[BUFFSIZ] = { 0 };

    while (NULL != fgets(buff, BUFFSIZ, stdin)) {
        int len = strlen(buff);
        int offset = 0;

        while (offset < len) {
            int nw = write(connfd, buff + offset, len - offset);
            if (-1 == nw && EINTR == errno) {
                continue;
            }
            else if (nw <= 0) {
                perror("write");
                exit(1);
            }
            else {
                offset += nw;
            }
        }

        offset = 0;
        while (len > 0) {
            int nr = read(connfd, buff + offset, len);
            if (-1 == nr) {
                if (EINTR != errno) {
                    perror("read");
                    exit(1);
                }
                continue;
            }
            else if (0 == nr) {
                printf("connection close by peer\n");
                exit(1);
            }
            else {
                len -= nr;
                offset += nr;
            }
        }

        if (-1 == fputs(buff, stdout)) {
            perror("fputs");
            break;
        }
    }
    if (ferror(stdin)) {
        perror("fgets");
    }

    close(connfd);
    exit(0);     
}
客户端用的是阻塞式IO，所以服务器关闭时不能在第一时间得知，解决方法有：1. 改成非阻塞式IO，见UNP第十六章；2. 加上心搏函数，见UNP第二十四章。


服务器:

LT模式的epoll实现:

#include <errno.h>
#include <netdb.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/epoll.h>
#include <cstdio>
#include <cstdlib>
#include <cstring>

const int LISTENQ = 1024;
const int EVENTSZ = 64;
const int BUFFSIZ = 4096;

int listen(const char * host, const char * serv)
{
    int               listenfd;
    int               n;
    const int         on = 1;
    struct addrinfo   hints;
    struct addrinfo * res;
    struct addrinfo * ressave;

    memset(&hints, 0, sizeof(hints));
    hints.ai_flags = AI_PASSIVE;
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;

    if (0 != (n = getaddrinfo(host, serv, &hints, &res))) {
        printf("getaddrinfo error for %s, %s: %s\n", 
               (NULL == host) ? "(no hostname)" : host, 
               (NULL == serv) ? "(no servname)" : serv, 
               gai_strerror(n));
        exit(1);
    }
    ressave = res;

    while (NULL != res) {
        listenfd = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
        if (-1 != listenfd) {
            setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
            if (0 == bind(listenfd, res->ai_addr, res->ai_addrlen)) {
                break;
            }
            else {
                close(listenfd);
            }
        }
        res = res->ai_next;
    }

    freeaddrinfo(ressave);

    if (NULL == res) {
        printf("listen failed\n");
        exit(1);
    }

    if (-1 == ::listen(listenfd, LISTENQ)) {
        printf("listen error: %s\n", strerror(errno));
        exit(1);
    }

    return(listenfd);
}

bool setnonblock(int sockfd)
{
    int flag = fcntl(sockfd, F_GETFL, 0);
    if (-1 == flag) {
        perror("fcntl(F_GETFL)");
        return(false);
    }
    if (-1 == fcntl(sockfd, F_SETFL, flag | O_NONBLOCK)) {
        perror("fcntl(F_SETFL)");
        return(false);
    }
    return(true);
}

int main(int argc, char ** argv)
{
    if (3 != argc) {
        printf("usage: %s <host> <serv>\n", argv[0]);
        exit(1);
    }

    struct epoll_event ev;
    struct epoll_event events[EVENTSZ];
    char buff[BUFFSIZ] = { 0 };

    int epollfd = epoll_create(LISTENQ);
    if (-1 == epollfd) {
        perror("epoll_create");
        exit(1);
    }

    int listenfd = listen(argv[1], argv[2]);

    ev.data.fd = listenfd;
    ev.events = EPOLLIN;
    if (-1 == epoll_ctl(epollfd, EPOLL_CTL_ADD, listenfd, &ev)) {
        perror("epoll_ctl(EPOLL_CTL_ADD)");
        exit(1);
    }

    for ( ; ; ) {
        int n = epoll_wait(epollfd, events, EVENTSZ, -1);
        if (-1 == n) {
            perror("epoll_wait");
            break;
        }

        for (int i = 0; i < n; ++i) {
            const int sockfd = events[i].data.fd;
            if (sockfd == listenfd) {
                int accefd = accept(listenfd, NULL, NULL);
                if (-1 == accefd) {
                    perror("accept");
                    exit(1);
                }

                ev.data.fd = accefd;
                ev.events = EPOLLIN;
                if (-1 == epoll_ctl(epollfd, EPOLL_CTL_ADD, accefd, &ev)) {
                    perror("epoll_ctl(EPOLL_CTL_ADD)");
                    close(accefd);
                }

                printf("connect by new client\n");
            }
            else {
                int nr = read(sockfd, buff, BUFFSIZ);
                if (nr <= 0) {
                    if (-1 == nr) {
                        perror("read");
                    }
                    else {
                        printf("connection close by peer\n");
                    }

                    if (-1 == epoll_ctl(epollfd, EPOLL_CTL_DEL, 
                                        sockfd, &ev)) {
                        perror("epoll_ctl(EPOLL_CTL_DEL)");
                    }
                    close(sockfd);
                    continue;
                }

                int nw = 0;
                while (nw < nr) {
                    int n = write(sockfd, buff + nw, nr - nw);
                    if (-1 == n && EWOULDBLOCK == errno) {
                        continue;
                    }
                    else if (n <= 0) {
                        break;
                    }
                    else {
                        nw += n;
                    }
                }
                if (nw < nr) {
                    if (-1 == epoll_ctl(epollfd, EPOLL_CTL_DEL, 
                                        sockfd, &ev)) {
                        perror("epoll_ctl(EPOLL_CTL_DEL)");
                    }
                    close(sockfd);
                }
            }
        }
    }

    close(epollfd);
    close(listenfd);
    exit(0);
}

ET模式的epoll实现:

#include <errno.h>
#include <netdb.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/epoll.h>
#include <cstdio>
#include <cstdlib>
#include <cstring>

const int LISTENQ = 1024;
const int EVENTSZ = 64;
const int BUFFSIZ = 4096;

int listen(const char * host, const char * serv)
{
    int               listenfd;
    int               n;
    const int         on = 1;
    struct addrinfo   hints;
    struct addrinfo * res;
    struct addrinfo * ressave;

    memset(&hints, 0, sizeof(hints));
    hints.ai_flags = AI_PASSIVE;
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;

    if (0 != (n = getaddrinfo(host, serv, &hints, &res))) {
        printf("getaddrinfo error for %s, %s: %s\n", 
               (NULL == host) ? "(no hostname)" : host, 
               (NULL == serv) ? "(no servname)" : serv, 
               gai_strerror(n));
        exit(1);
    }
    ressave = res;

    while (NULL != res) {
        listenfd = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
        if (-1 != listenfd) {
            setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
            if (0 == bind(listenfd, res->ai_addr, res->ai_addrlen)) {
                break;
            }
            else {
                close(listenfd);
            }
        }
        res = res->ai_next;
    }

    freeaddrinfo(ressave);

    if (NULL == res) {
        printf("listen failed\n");
        exit(1);
    }

    if (-1 == ::listen(listenfd, LISTENQ)) {
        printf("listen error: %s\n", strerror(errno));
        exit(1);
    }

    return(listenfd);
}

bool setnonblock(int sockfd)
{
    int flag = fcntl(sockfd, F_GETFL, 0);
    if (-1 == flag) {
        perror("fcntl(F_GETFL)");
        return(false);
    }
    if (-1 == fcntl(sockfd, F_SETFL, flag | O_NONBLOCK)) {
        perror("fcntl(F_SETFL)");
        return(false);
    }
    return(true);
}

int main(int argc, char ** argv)
{
    if (3 != argc) {
        printf("usage: %s <host> <serv>\n", argv[0]);
        exit(1);
    }

    struct epoll_event ev;
    struct epoll_event events[EVENTSZ];
    char buff[BUFFSIZ] = { 0 };

    int epollfd = epoll_create(LISTENQ);
    if (-1 == epollfd) {
        perror("epoll_create");
        exit(1);
    }

    int listenfd = listen(argv[1], argv[2]);
    if (!setnonblock(listenfd)) {
        exit(1);
    }

    ev.data.fd = listenfd;
    ev.events = EPOLLIN | EPOLLET;
    if (-1 == epoll_ctl(epollfd, EPOLL_CTL_ADD, listenfd, &ev)) {
        perror("epoll_ctl(EPOLL_CTL_ADD)");
        exit(1);
    }

    for ( ; ; ) {
        int n = epoll_wait(epollfd, events, EVENTSZ, -1);
        if (-1 == n) {
            perror("epoll_wait");
            break;
        }

        for (int i = 0; i < n; ++i) {
            const int sockfd = events[i].data.fd;
            if (sockfd == listenfd) {
                for ( ; ; ) {
                    int accefd = accept(listenfd, NULL, NULL);
                    if (-1 == accefd) {
                        if (EAGAIN == errno) {
                            break;
                        }
                        continue;
                    }

                    if (!setnonblock(accefd)) {
                        close(accefd);
                        continue;
                    }

                    ev.data.fd = accefd;
                    ev.events = EPOLLIN | EPOLLET;
                    if (-1 == epoll_ctl(epollfd, EPOLL_CTL_ADD, accefd, &ev)) {
                        perror("epoll_ctl(EPOLL_CTL_ADD)");
                        close(accefd);
                    }

                    printf("connect by new client\n");
                }
            }
            else {
                for ( ; ; ) {
                    int nr = read(sockfd, buff, BUFFSIZ);
                    if (-1 == nr && EAGAIN == errno) {
                        break;
                    }

                    if (0 == nr) {
                        printf("connection close by peer\n");
                    }

                    if (nr <= 0) {
                        if (-1 == epoll_ctl(epollfd, EPOLL_CTL_DEL, 
                                            sockfd, &ev)) {
                            perror("epoll_ctl(EPOLL_CTL_DEL)");
                        }
                        close(sockfd);
                        break;
                    }

                    int nw = 0;
                    while (nw < nr) {
                        int n = write(sockfd, buff + nw, nr - nw);
                        if (-1 == n && EWOULDBLOCK == errno) {
                            continue;
                        }
                        else if (n <= 0) {
                             break;
                        }
                        else {
                            nw += n;
                        }
                    }
                    if (nw < nr) {
                        if (-1 == epoll_ctl(epollfd, EPOLL_CTL_DEL, 
                                            sockfd, &ev)) {
                            perror("epoll_ctl(EPOLL_CTL_DEL)");
                        }
                        close(sockfd);
                        break;
                    }
                }
            }
        }
    }

    close(epollfd);
    close(listenfd);
    exit(0);
}
ET模式的epoll实现，在write时处理得不好，因为sockfd是非阻塞的，所以当发送缓存不足时，write会一直返回-1(errno为EWOULDBLOCK)，直到有足够的发送缓存。我估计要把EPOLLOUT加到sockfd的对应event中，但这样就得为每个sockfd分配一块独立的缓存，更重要的是，我们可能得反复调用epoll_ctl(EPOLL_CTL_MOD)去增 / 减EPOLLIN / EPOLLOUT，这会降低多少效率是最值得关心的。


当然对于回射服务器没必要这样做。


Linux下的socket编程实践（九） epoll实现高并发的原理及其使用
NK_test的博客
10-22 9458
在 linux 没有实现 epoll 事件驱动机制之前，我们一般选择用 selec t或者 poll 等IO多路复用的方法来实现并发服务程序（详见此链接）。在大数据、高并发、集群等一些名词唱得火热之年代，select 和 poll的用武之地越来越有限，风头已经被 epoll 占尽。  本文便来介绍 epoll 的实现机制，并通过对比其不同的实现机制，真正理解为何 epoll 能实现高并发
Socket编程实践(11) --epoll原理与封装
weixin_30488085的博客
03-11 359
常用模型的特点 Linux下设计并发网络程序,有典型的Apache模型(ProcessPerConnection,PPC),TPC(ThreadPerConnection)模型，以及select/polL模型和epoll模型。1、PPC/TPC模型 这两种模型思想类似，就是让每一个到来的连接一边自己做事去，别再来烦我(详见本系列博客).只是PPC是为它开了一...
epoll模型的探索与实践
weixin_34291004的博客
06-20 187
我们知道nginx的效率非常高,能处理上万级的并发,其之所以高效离不开epoll的支持, epoll是什么呢?,epoll是IO模型中的一种,属于多路复用IO模型; 到这里你应该想到了,select,的确select也是一种多路复用的IO模型,但是其单个select最多只能同时处理1024个socket,效率实在算不上高,这时候epoll来救场了 本文从阻塞IO模型的基础上展开讨论,一步步靠...
I/O非阻塞函数实践：epoll
leilixu的专栏
06-05 645
epoll函数是poll函数的改良版，同样与
【网络】epoll理论 + 实践（LT模式服务器和ET模式服务器）详细讲解
最新发布
You don't have the guts to be what you wanna be.
11-09 651
- 三个Epoll接口 - Epoll原理 - 编写Epoll的LT模式服务器 - 编写Epoll的ET模式服务器
epoll学习及实例
罗布泊coding
01-06 2079
epoll是Linux内核为处理大批量文件描述符而作了改进的poll，是Linux下多路复用IO接口select/poll的增强版本，是IO多路复用的一种技术。它能显著提高程序在大量并发连接中只有少量活跃的情况下的系统CPU利用率。 在linux的网络编程中，很长的时间都在使用select来做事件触发。在linux新的内核中，有了一种替换它的机制，就是epol...
Linux下TCP穿透NAT源代码实现与epoll实践
文件名称“epoll_demo”暗示了该程序可能是一个使用epoll机制来提高网络I/O效率的示例。该程序能够演示如何在高并发的网络环境下，通过epoll来提升网络处理性能。 通过上述知识点的深入阐述，我们可以了解到Linux...
深入网络连接库：C++与Linux下的epoll实践
使用epoll时，通常先通过`epoll_create()`创建一个epoll对象，然后使用`epoll_ctl()`来添加、修改或删除监控的文件描述符，最后使用`epoll_wait()`来等待事件的发生。 #### 连接的自动收发消息 在网络编程中，自动...
linux epoll多线程编程 例子
01-19
通过阅读《线程池 + epoll 简单的实现.txt》文件，我们可以获取更具体的代码实现和实践细节。《MyLinuxThread.txt》文件可能包含了一个关于如何在Linux上使用epoll和线程池进行编程的实例，这将有助于加深对这一主题...
epoll网络模型
11-06
`epoll`是Linux系统提供的一种I/O多路复用技术，相较于传统的`select`和`poll`，它在处理大量并发连接时表现出更高的效率和性能。本项目使用C++编程语言，在Ubuntu环境下开发，利用`g++`编译器进行编译，包含了`...
tinyhttpd-epoll:Tinyhttpd的epoll端口
07-06
Tinyhttpd是一个小型的、开源的HTTP服务器，最初由Chris Nandor编写，设计目标是简单易用，便于教学和理解...对于想要提升自己在C语言和网络编程方面技能的IT从业者来说，研究和实践这个项目会是一个很好的学习机会。
痛苦的epoll+线程池实践 2 相关模式的设置
terminator3的专栏
11-23 655
参见 《经验实在太重要了：epoll的一些补充》 epoll模式分为ET边缘模式和 LT水平模式 IO 阻塞模式分为 阻塞和非阻塞 1、ET边缘模式（listen socket fd）+非阻塞（listen socket fd）   可以使用同一线程的epoll，但是应注意如果是 listen socket fd可读，应使用 while 重复 accept 多个连接 2、ET边缘
Linux网络编程 - 剖析 epoll 的底层实现
囚牢-峰子的博客
03-17 635
基本数据结构 ...
select、poll和epoll的实践理解
lovego123的博客
05-02 559
select、poll和epoll本质上都是实现IO多路复用的并发模型，主要区别在于应用场景和实现机制的不同。selectselect是将所有的描述符状态保存进fd_set中，然后遍历fd_set的状态变化来进行相应的操作。它的主要缺点有：采用轮询的方式遍历所有描述符的状态，当数量较多时效率低下；单个进程支持最大并发连接的数量有限，通常为1024个；大量的fd_set数据结构需要从用户到内核的不断...
高并发网络编程之epoll详解
freedom8531的专栏
09-11 4926
http://www.cricode.com/3499.html
我读过的最好的epoll讲解--转自”知乎“
weixin_34015336的博客
06-05 9416
作者：蓝形参，Geek 伪技术宅    首先我们来定义流的概念，一个流可以是文件，socket，pipe等等可以进行I/O操作的内核对象。    不管是文件，还是套接字，还是管道，我们都可以把他们看作流。    之后我们来讨论I/O的操作，通过read，我们可以从流中读入数据；通过write，我们可以往流写入数据。现在假定一个情形，我们需要从流中读数据，但是流中还没有数据，（典型的例子为，客户端要...
eBCC性能分析最佳实践（0） - 开启性能分析新篇章
Linux阅码场
05-01 749
From阿里 姜弋内核月谈Guide:eBCC性能分析最佳实践（0） - 开启性能分析新篇章eBCC性能分析最佳实践（1） - 线上lstat, vfs_fstatat...
Linux下 select/epoll
雪飞_海
07-02 876
一、Unix/Linux网络IO模型 在经典的Unix网络编程中，总结出了5种不同的网络IO模型，分别是阻塞式IO，非阻塞IO, IO多路复用，信号驱动IO，以及异步IO模型。 1. 阻塞式IO 2. 非阻塞式IO 3. IO多路复用 4. 信号驱动式IO 5. 异步IO模型 二、为什么IO多路复用应用最广泛 异步IO模型：理论上来说性能更好，但是目前阶段在linux平台下，操作系统底层并没有真正实现完全异步IO...
菜鸟学习nginx之事件模块epoll（1）
程序员的世界
01-01 1448
上一篇介绍核心事件模块，本篇介绍事件模块ngx_epoll_module。Nginx在linux环境下采用epoll网络模型，对于epoll网络型不了解的可自行百度查询，本篇不在阐述。 一、问题 本篇要澄清以下几个问题： 1、当客户端发起TCP连接后，事件模块是如何管理新连接？ 2、Nginx是如何接收到客户端请求（只是TCP层请求非HTTP请求）？ 3、Nginx是如何发送响应给客户端...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值