细节问题记录

原创 已于 2023-07-19 11:31:42 修改 · 2.4k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++

于 2022-04-11 10:32:37 首次发布
本文通过一个示例程序详细介绍了如何将同一个非阻塞socket套接字放入两个epoll实例中，并讨论了在读取事件发生时的行为。当读事件触发时，系统可能会随机选择一个epoll实例进行读取，如果数据未完全读取，则可能触发另一个epoll实例。此外，文章还提到了QTcpSocket的readyRead信号，其工作原理类似epoll，当有数据到达时触发，并在数据未读完时不重复触发。关于epoll的惊群现象，作者指出可以通过设置EPOLLEXCLUSIVE或使用锁来避免。最后，文章讨论了关闭套接字与EPOLL_CTL_DEL的关系，表明关闭套接字会自动从epoll中移除。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1、当同一个系统非阻塞socket套接字往两个epoll放后，出现读事件时会是什么样子?
// 测试代码
/*************************************************************************
    > File Name: test_epoll.cc
    > Author: hsz
    > Brief: 测试同一套接字放进两个epoll
    > Created Time: 2022-04-11 09:36:35 Monday
 ************************************************************************/

#include <log/log.h>
#include <utils/Errors.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <netinet/tcp.h>
#include <sys/time.h>
#include <sys/epoll.h>
#include <functional>
#include <thread>

#define LOG_TAG "test epoll"

int InitSocket(uint16_t port = 8000)
{
    int sock = ::socket(AF_INET, SOCK_STREAM, 0);
    if (sock < 0) {
        LOGE("socket error. error code = %d, error message: %s", errno, strerror(errno));
        return eular::UNKNOWN_ERROR;
    }
    sockaddr_in server_addr;
    bzero(&server_addr, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(port);
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY); //inet_addr("172.25.12.215");

    int opt = 1;
    setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    if (::bind(sock, (sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
        LOGE("bind error. error code = %d, error message: %s", errno, strerror(errno));
        goto error_return;
    }
    if (::listen(sock, 128) < 0) {
        LOGE("listen error. error code = %d, error message: %s", errno, strerror(errno));
        goto error_return;
    }
    return sock;

error_return:
    ::close(sock);
    return eular::UNKNOWN_ERROR;
}

static const uint16_t EPOLL_EVENT_SIZE = 8;

void thread_1(int fd)
{
    LOGI("%s()", __func__);
    struct epoll_event event;
    struct epoll_event allEvent[EPOLL_EVENT_SIZE];

    int epollfd = epoll_create(EPOLL_EVENT_SIZE);
    if (epollfd < 0) {
        perror("epoll_create error");
        exit(0);
    }

    event.data.fd = fd;
    event.events = EPOLLET | EPOLLIN;
    epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &event);

    while (1) {
        int nev = epoll_wait(epollfd, allEvent, EPOLL_EVENT_SIZE, -1);
        if (nev <= 0) {
            perror("epoll_wait error");
            exit(0);
        }

        for (int i = 0; i < nev; ++i) {
            auto &ev = allEvent[i];
            if (ev.events & (EPOLLHUP | EPOLLERR | EPOLLRDHUP)) {
                LOGI("%s() client %d quit", __func__, ev.data.fd);
                epoll_ctl(epollfd, EPOLL_CTL_DEL, ev.data.fd, nullptr);
                continue;
            }

            if (ev.events & EPOLLIN) {
                static char buf[8] = {0};
                memset(buf, 0, sizeof(buf));
                int readSize = recv(ev.data.fd, buf, sizeof(buf), 0);
                LOGI("recv: %s", buf);
                if (readSize < 0) {
                    if (errno != EAGAIN) {
                        perror("thread_1 read error");
                    }
                }
            }
        }
    }
}

void thread_2(int fd)
{
    LOGI("%s()", __func__);
    struct epoll_event event;
    struct epoll_event allEvent[EPOLL_EVENT_SIZE];

    int epollfd = epoll_create(EPOLL_EVENT_SIZE);
    if (epollfd < 0) {
        perror("epoll_create error");
        exit(0);
    }

    event.data.fd = fd;
    event.events = EPOLLET | EPOLLIN;
    epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &event);

    while (1) {
        int nev = epoll_wait(epollfd, allEvent, EPOLL_EVENT_SIZE, -1);
        if (nev <= 0) {
            perror("thread_2 epoll_wait error");
            exit(0);
        }

        for (int i = 0; i < nev; ++i) {
            auto &ev = allEvent[i];

            if (ev.events & (EPOLLHUP | EPOLLERR | EPOLLRDHUP)) {
                LOGI("%s() client %d quit", __func__, ev.data.fd);
                epoll_ctl(epollfd, EPOLL_CTL_DEL, ev.data.fd, nullptr);
                continue;
            }

            if (ev.events & EPOLLIN) {
                static char buf[8] = {0};
                memset(buf, 0, sizeof(buf));
                int readSize = recv(ev.data.fd, buf, sizeof(buf), 0);
                LOGI("recv: %s", buf);
                if (readSize < 0) {
                    if (errno != EAGAIN) {
                        perror("thread_2 read error");
                    }
                }
            }
        }
    }
}

int main(int argc, char **argv)
{
    int sock = InitSocket();
    LOG_ASSERT2(sock > 0);

    int clientSock = 0;

    LOGI("%d waiting for client... ", sock);
    while (1) {
        sockaddr_in addr;
        socklen_t len = sizeof(sockaddr_in);
        clientSock = ::accept(sock, (sockaddr *)&addr, &len);
        if (clientSock > 0) {
            break;
        } else {
            perror("accept error");
        }
    }

    int flags = fcntl(clientSock, F_GETFL, 0);
    fcntl(clientSock, F_SETFL, flags | O_NONBLOCK);
    int keepAlive = 1;      // 开启keepalive属性
    int keepIdle = 3;       // 如该连接在60秒内没有任何数据往来,则进行探测 
    int keepInterval = 2;   // 探测时发包的时间间隔为5 秒
    int keepCount = 2;      // 探测尝试的次数.如果第1次探测包就收到响应了,则后2次的不再发.
    setsockopt(clientSock, SOL_SOCKET, SO_KEEPALIVE, (void *)&keepAlive, sizeof(keepAlive));
    setsockopt(clientSock, SOL_TCP, TCP_KEEPIDLE, (void*)&keepIdle, sizeof(keepIdle));
    setsockopt(clientSock, SOL_TCP, TCP_KEEPINTVL, (void *)&keepInterval, sizeof(keepInterval));
    setsockopt(clientSock, SOL_TCP, TCP_KEEPCNT, (void *)&keepCount, sizeof(keepCount));

    std::thread th1(std::bind(thread_1, clientSock));
    std::thread th2(std::bind(thread_2, clientSock));

    th1.join();
    th2.join();

    return 0;
}

1、 系统非阻塞套接字边沿触发 \color{#FF3030}{系统非阻塞套接字边沿触发} 系统非阻塞套接字边沿触发
将同一套接字存入两个epoll后并触发读事件时，会随机调用其中一个epoll来读，当全部读完后不再触发第二个epoll，但读不完时则会触发第二个epoll如图
(1) 一次读完客户端发送的数据
在这里插入图片描述
(2) 不一次读完
在这里插入图片描述

2、QTcpSocket的readyRead信号触发机制
// 当对端tcp发送过来数据后会触发，读不完数据，只能等下次对面发送数据才会在次触发
// 类似epoll
void MainWidget::onTcpSocketCanRead()
{
    qDebug("%s() %lld", __func__, mTcpClient->bytesAvailable());
    char buf[16] = {0};
    int readSize = mTcpClient->read(buf, 4);
    qDebug("%s() read size %d, available size %lld", __func__, readSize, mTcpClient->bytesAvailable());
}

在这里插入图片描述
在这里插入图片描述
从epoll和qt两张图中可以看出，其机制类似

3、epoll惊群现象

现象描述：
多个线程同时epoll_wait(一个调用对应一个epoll对象)一个socket句柄，当有一个套接字产生事件时会出现几个线程一起唤醒，但只有一个才能正确读到，其他在读时返回EAGAIN。(就是例子1中给出的)
解决办法：
1、对EAGAIN不处理
2、进行加锁处理(nginx做法)
3、EPOLLEXCLUSIVE (参考)

4、关闭套接字和EPOLL_CTL_DEL

进过几次试验得知，调用close关闭套接字后，内核会发出一个事件通知，epoll 实例会检测到该事件，并将相应的套接字从监视列表中删除。故不需要在删除，当前可以在关闭套接字之前先从epoll删除套接字再关闭

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值