Bootstrap

TinyWebserver的复现与改进（6）：定时器处理非活动连接

如果客户端长时间没有动作，会占用了许多连接资源，严重影响服务器的性能。因此需要通过实现一个服务器定时器，处理这种非活跃连接，释放连接资源。

定时器处理流程

image-20240816210048538

  1. SIGALARM触发：整个流程开始于一个 SIGALARM 信号，该信号每5秒会触发一次。
  2. 发送消息：当SIGALARM触发时，会进入 sig_handler 中断服务函数中，在该函数中，会向管道写端发送数据
  3. Epoll轮询：管道读端接收到消息后，使用 epoll 模型对所有的 socket（特别是管道读端 pipefd[0] ）连接进行轮询。由于管道读端有数据，会将 timeout ➡ true
  4. Tick计时器：当 timeout 为 true 时，会进入tick 函数中检查连接是否超时，由于定时器的数据结构是一个链表，所以这个过程实际上是链表的查询操作
  5. 超时处理：当链表查询到客户端超时连接时，服务器会调用 cb_func 回调函数来断开这些连接。在这个函数中，服务器可能会执行一些必要的清理工作，比如从 epoll 监视的 socket 列表中删除超时的 sockfd，以及删除定时器。
  6. 重定时：当查询到各个客户端都不超时或者执行完 cb_func 时，会重新给 SIGALARM 信号 定时5s，然后等待下一次触发

定时器的实现

struct client_data
{
    sockaddr_in address;
    int sockfd;
    util_timer *timer;
};

// 定时器类
class util_timer{
public:
    // 构造函数
    util_timer(): prev(NULL), next(NULL) {}

public:
    time_t expire; // 任务超时时间，这里是使用绝对时间
    void (*cb_func)(client_data*);  // 任务回调函数， 回调函数处理的客户数据，由定时器的执行者传递给回调函数
    client_data* user_data;
    util_timer* prev;
    util_timer* next;
};

定时器实际上是链表的一个节点，里面存着任务超时时间，这里是使用绝对时间，以及任务的回调函数（cb_func），客户端数据使用的是一个额外的结构体，里面有客户端的地址族、sockfd、以及下一个定时器的指针。（当然也可以用http_conn这个数据类，但比较麻烦）

每个客户端都会产生一个定时器结点，它会存储在一个定时器链表中。

// 定时器链表, 是升序的双向链表, 带有头节点和尾节点
class sort_timer_lst{
public:
    sort_timer_lst();
    // 析构函数
    ~sort_timer_lst();

    // 将目标定时器放在链表中
    void add_timer(util_timer* timer);

    // 将定时器 timer 从链表中删除
    void del_timer(util_timer* timer);

    // 当某个定时任务发生变化, 调整该定时器在链表中的位置，此函数只考虑定时时间延长的情况，即定时器往链表的后面移动
    void adjust_timer(util_timer* timer);

    /* SIGALARM每触发一次就在信号处理函数执行一次tick函数, 以处理链表上的到期任务 */
    void tick();

    util_timer* head;
    util_timer* tail;
private:

    // 将目标定时器 timer 添加到节点 lst_head 之后的部分链表中
    void add_timer(util_timer* timer, util_timer* lst_head)
    {
        util_timer* prev = lst_head;
        util_timer* tmp = prev->next;

        while(tmp)
        {
            if(timer->expire < tmp->expire)
            {
                prev->next = timer;
                timer->next = tmp;
                tmp->prev = timer;
                timer->prev = prev;
                break;
            }
            prev = tmp;
            tmp = tmp->next;
        }

        // timer->expire 是最大的，则插入到末尾
        if(!tmp)
        {
            prev->next = timer;
            timer->prev = prev;
            timer->next = NULL;
            tail = timer;
        }
    }
};

这个链表类函数的增删改查都与链表的差不多，对此不再赘述

具体函数说明

sig_handler

// 信号的中断处理函数
void timer_sig_handler(int sig)
{
    int save_errno = errno;
    int msg = sig;
    send(pipefd[1], (char*)&msg, 1, 0);
    errno = save_errno;
}
  • pipefd[0] 对应的是管道的读端，pipefd[1] 对应的是管道的写端

这个函数是向管道写端写入信号（alarm）的值

cb_func

// 定时器回调函数, 从epoll上删除sockfd
void cb_func(client_data *user_data)
{
    printf("close fd : %d\n", user_data->sockfd);
    epoll_ctl(epollfd, EPOLL_CTL_DEL, user_data->sockfd, 0);
    assert(&user_data);
    close(user_data->sockfd);
}

初始化

// 信号的初始化
void timer_sig_init()
{
    // 创建
    int ret = socketpair(AF_UNIX, SOCK_STREAM, 0, pipefd);
    assert(ret != -1);
    setnonblocking(pipefd[1]);
    addfd(epollfd, pipefd[0], false);
    addsig(SIGALRM, timer_sig_handler);
    addsig(SIGTERM, timer_sig_handler);
}
  • socketpair 函数用于创建一个全双工的、相互连接的、无名的套接字对。这两个套接字就像是同一个管道的两端，但它们是网络通信的范畴，而不是进程间管道通信的范畴。（简单来说就是模拟成管道通信）
  • 在默认情况下，当使用 write 或 send 函数向管道写入数据时，如果管道的读端缓冲区已满，写操作将被阻塞，直到有空间可用。因此我们需要将 pipefd[1] 设置为非堵塞，防止服务器卡在某一个地方

将新客户端添加到链表中

//初始化client_data数据
//创建定时器，设置回调函数和超时时间，绑定用户数据，将定时器添加到链表中
users_timer[connfd].address = client_address;
users_timer[connfd].sockfd = connfd;
util_timer *timer = new util_timer;
timer->user_data = &users_timer[connfd];
timer->cb_func = cb_func;
time_t cur = time(NULL);
timer->expire = cur + 3*TIMESLOT;
users_timer[connfd].timer = timer;
timer_lst.add_timer(timer);

读端有数据

else if((sockfd == pipefd[0])&&(events[i].events & EPOLLIN))
{
    int sig;
    char signals[1024];
    ret = recv(pipefd[0], signals, sizeof(signals), 0);
    if (ret == -1)
    {
        continue;
    }
    else if (ret == 0)
    {
        continue;
    }
    else
    {
        for (int i = 0; i < ret; ++i)
        {
            switch (signals[i])
            {
            case SIGALRM:
            {
                timeout = true;
                break;
            }
            case SIGTERM:
            {
                stop_server = true;
            }
            }
        }
    }
}

当 pipe 读端有数据时，会进入这个if循环中，然后使用 recv 读取”管道“的数据，再依次判断

系列文章

GitHub - yzfzzz/MyWebServer: Linux高并发服务器项目，参考了TinyWebServer，将在此基础上进行性能改进与功能增加。为方便读者学习，附带详细注释和博客！

webserver

TinyWebserver的复现与改进（1）：服务器环境的搭建与测试-CSDN博客

TinyWebserver的复现与改进（2）：项目的整体框架-CSDN博客

TinyWebserver的复现与改进（3）：线程同步机制类封装及线程池实现-CSDN博客

TinyWebserver的复现与改进（4）：主线程的具体实现-CSDN博客

TinyWebserver的复现与改进（5）：HTTP报文的解析与响应-CSDN博客

完整代码

main.cpp

#include <arpa/inet.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>
#include <stdlib.h>
#include <sys/epoll.h>
#include "threadpool.hpp"
#include "locker.h"
#include "http_conn.h"
#include <signal.h>
#include <assert.h>  
#include "lst_timer.h"
#define MAX_FD 65536  // 最大的文件描述符
#define MAX_EVENT_NUMBER 10000 // 监听的最大事件数
#define TIMESLOT 5
//设置定时器相关参数
static int pipefd[2];
static sort_timer_lst timer_lst;
static int epollfd = 0;
// 信号的中断处理函数
void timer_sig_handler(int sig)
{
    int save_errno = errno;
    int msg = sig;
    send(pipefd[1], (char*)&msg, 1, 0);
    errno = save_errno;
}
// 定时器回调函数, 从epoll上删除sockfd
void cb_func(client_data *user_data)
{
    printf("close fd : %d\n", user_data->sockfd);
    epoll_ctl(epollfd, EPOLL_CTL_DEL, user_data->sockfd, 0);
    assert(&user_data);
    close(user_data->sockfd);
}
void timer_handler()
{
    timer_lst.tick();
    alarm(TIMESLOT);
}
/* 
    函数指针的声明: 类型说明符 (*函数名) (参数)
    void(handler)(int) 声明了一个名为 handler 的函数指针，它指向一个接受一个 int 参数并返回 void 的函数
*/
void addsig(int sig, void(handler)(int), bool restart = false)
{
    // sigaction的输入参数
    struct sigaction sa;
    // 指定sa内存区域的前n个字节都设置为某个特定的值('\0')，用于对新分配的内存进行初始化
    memset(&sa, '\0', sizeof(sa));
    // 写入函数指针，指向的函数就是信号捕捉到之后的处理函数
    sa.sa_handler = handler;
    if(restart)
        sa.sa_flags |= SA_RESTART;
    // 设置临时阻塞信号集
    sigfillset(&sa.sa_mask);
    assert(sigaction(sig, &sa, NULL) != -1);
}

// 信号的初始化
void timer_sig_init()
{
    int ret = socketpair(AF_UNIX, SOCK_STREAM, 0, pipefd);
    assert(ret != -1);
    setnonblocking(pipefd[1]);
    addfd(epollfd, pipefd[0], false);
    addsig(SIGALRM, timer_sig_handler);
    addsig(SIGTERM, timer_sig_handler);
}

int main(int argc, char* argv[])
{
    if(argc <= 1)
    {
        // 要求输入格式为 ./a.out 10000  其中10000是端口号 
        printf("usage: %s port_number\n", basename(argv[0]));
        return 1;
    }

    // 端口号 string -> int
    int port = atoi(argv[1]);
    // 如果向一个没有读端的管道写数据，不用终止进程
    addsig(SIGPIPE, SIG_IGN);   // SIG_IGN: 忽略信号，这里指的是忽略信号 ·  SIGPIPE

    // 定义一个线程池指针
    threadpool<http_conn>* pool = NULL;
    try {
        // 开辟一个线程池
        pool = new threadpool<http_conn>;
    }catch(...)
    {
        // 若异常则退出
        return 1;
    }
    // 开辟一块连续的http_conn数组，保存所有正在连接的客户端信息
    http_conn* users = new http_conn[MAX_FD];
    client_data *users_timer = new client_data[MAX_FD];

    // 设置监听
    int listenfd = socket(AF_INET, SOCK_STREAM, 0);
    int ret = 0;
    struct sockaddr_in address;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_family = AF_INET;
    address.sin_port = htons(port);

    // 设置端口复用
    int reuse = 1;
    setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));

    // 绑定
    ret = bind(listenfd, (struct sockaddr*)&address, sizeof(address));
    if(ret == -1)
    {
        perror("bind");
        exit(-1);
    }

    // 开始监听
    ret = listen(listenfd, 5);
    if(ret == -1)
    {
        perror("listen");
        exit(-1);
    }
    
    // 将listend添加到epoll模型中
    epoll_event events[MAX_EVENT_NUMBER];
    epollfd = epoll_create(5);
    addfd(epollfd, listenfd, false);
    http_conn::m_epollfd = epollfd;

    timer_sig_init();

    bool timeout = false;
    bool stop_server = false;
    alarm(TIMESLOT);
    while(!stop_server)
    {
        // epoll轮询，等待有数据发送
        int number = epoll_wait(epollfd, events, MAX_EVENT_NUMBER,-1);
        if((number < 0) && (errno != EINTR))
        {
            printf("epoll failture\n");
            break;
        }
        for(int i = 0; i < number; i++)
        {
            int sockfd = events[i].data.fd;
            // 有新的客户端连接
            if(sockfd == listenfd)
            {
                struct sockaddr_in client_address;
                socklen_t client_addresslen = sizeof(client_address);
                int connfd = accept(listenfd, (struct sockaddr*)&client_address, &client_addresslen);

                if(connfd < 0)
                {
                    printf("errno is %d\n", errno);
                    continue;
                }

                if(http_conn::m_user_count >= MAX_FD)
                {
                    close(connfd);
                    continue;
                }
                users[connfd].init(connfd, client_address);
                //初始化client_data数据
                //创建定时器，设置回调函数和超时时间，绑定用户数据，将定时器添加到链表中
                users_timer[connfd].address = client_address;
                users_timer[connfd].sockfd = connfd;
                util_timer *timer = new util_timer;
                timer->user_data = &users_timer[connfd];
                timer->cb_func = cb_func;
                time_t cur = time(NULL);
                timer->expire = cur + 3*TIMESLOT;
                users_timer[connfd].timer = timer;
                timer_lst.add_timer(timer);
            }
            else if((sockfd == pipefd[0])&&(events[i].events & EPOLLIN))
            {
                int sig;
                char signals[1024];
                ret = recv(pipefd[0], signals, sizeof(signals), 0);
                if (ret == -1)
                {
                    continue;
                }
                else if (ret == 0)
                {
                    continue;
                }
                else
                {
                    for (int i = 0; i < ret; ++i)
                    {
                        switch (signals[i])
                        {
                        case SIGALRM:
                        {
                            timeout = true;
                            break;
                        }
                        case SIGTERM:
                        {
                            stop_server = true;
                        }
                        }
                    }
                }
            }

            // 若对方异常端开或错误
            else if(events[i].events & (EPOLLRDHUP | EPOLLHUP | EPOLLERR))
            {
                users[sockfd].close_conn();
            }
            // 有读事件发生（可读）
            else if(events[i].events & EPOLLIN)
            {
                util_timer *timer = users_timer[sockfd].timer;
                // 有读事件发生
                if(users[sockfd].read())
                {
                    // 读的到数据
                    pool->append(users+sockfd);

                    //若有数据传输，则将定时器往后延迟3个单位
                    //并对新的定时器在链表上的位置进行调整
                    if (timer)
                    {
                        time_t cur = time(NULL);
                        timer->expire = cur + 3 * TIMESLOT;
                        timer_lst.adjust_timer(timer);
                    }
                }
                else
                {
                    printf("Read Fail!\n");
                    // 读不到数据
                    timer->cb_func(&users_timer[sockfd]);
                    if (timer)
                    {
                        timer_lst.del_timer(timer);
                    }
                    // users[sockfd].close_conn();

                }
            }
            // 有写事件发生（可写）
            else if(events[i].events & EPOLLOUT)
            {
                util_timer *timer = users_timer[sockfd].timer;
                if(users[sockfd].write())
                {
                    if (timer)
                    {
                        time_t cur = time(NULL);
                        timer->expire = cur + 3 * TIMESLOT;
                        timer_lst.adjust_timer(timer);
                    }
                }
                else
                {
                    printf("Write Fail!\n");
                    timer->cb_func(&users_timer[sockfd]);
                    if (timer)
                    {
                        timer_lst.del_timer(timer);
                    }
                    // users[sockfd].close_conn();
                }
            }
        }
        if (timeout)
        {
            timer_handler();
            timeout = false;
        }
    }

    close(epollfd);
    close(listenfd);
    close(pipefd[1]);
    close(pipefd[0]);
    delete [] users;
    delete[] users_timer;
    delete pool;
    return 0;
}

lst_timer.h

#pragma once
#include <stdio.h>
#include <time.h>
#include <arpa/inet.h>
#define BUFFER_SIZE 64

class util_timer;
struct client_data
{
    sockaddr_in address;
    int sockfd;
    util_timer *timer;
};

// 定时器类
class util_timer{
public:
    // 构造函数
    util_timer(): prev(NULL), next(NULL) {}

public:
    time_t expire; // 任务超时时间，这里是使用绝对时间
    void (*cb_func)(client_data*);  // 任务回调函数， 回调函数处理的客户数据，由定时器的执行者传递给回调函数
    client_data* user_data;
    util_timer* prev;
    util_timer* next;
};

// 定时器链表, 是升序的双向链表, 带有头节点和尾节点
class sort_timer_lst{
public:
    sort_timer_lst();
    // 析构函数
    ~sort_timer_lst();

    // 将目标定时器放在链表中
    void add_timer(util_timer* timer);

    // 将定时器 timer 从链表中删除
    void del_timer(util_timer* timer);

    // 当某个定时任务发生变化, 调整该定时器在链表中的位置，此函数只考虑定时时间延长的情况，即定时器往链表的后面移动
    void adjust_timer(util_timer* timer);

    /* SIGALARM每触发一次就在信号处理函数执行一次tick函数, 以处理链表上的到期任务 */
    void tick();

    util_timer* head;
    util_timer* tail;
private:

    // 将目标定时器 timer 添加到节点 lst_head 之后的部分链表中
    void add_timer(util_timer* timer, util_timer* lst_head)
    {
        util_timer* prev = lst_head;
        util_timer* tmp = prev->next;

        while(tmp)
        {
            if(timer->expire < tmp->expire)
            {
                prev->next = timer;
                timer->next = tmp;
                tmp->prev = timer;
                timer->prev = prev;
                break;
            }
            prev = tmp;
            tmp = tmp->next;
        }

        // timer->expire 是最大的，则插入到末尾
        if(!tmp)
        {
            prev->next = timer;
            timer->prev = prev;
            timer->next = NULL;
            tail = timer;
        }
    }
};

lst_timer.cpp

#include "lst_timer.h"
#include <signal.h>
#include <errno.h>
#include <cassert>
sort_timer_lst::sort_timer_lst(): head(NULL), tail(NULL){}
// 析构函数
sort_timer_lst::~sort_timer_lst()
{
    util_timer* tmp = head;
    while(tmp)
    {
        head = tmp->next;
        delete tmp;
        tmp = head;
    }
}

// 将目标定时器放在链表中
void sort_timer_lst::add_timer(util_timer* timer)
{
    if(!timer)
    {
        return;
    }
    if(!head)
    {
        head = tail = timer;
        return;
    }
    /* 
        如果目标定时器的超时时间小于当前链表中所有定时器的超时时间，
        则把该定时器插入链表头部,作为链表新的头节点，否则就需要调用
        重载函数 add_timer(),把它插入链表中合适的位置，以保证链表的升序特性 
    */
    if(timer->expire < head->expire)
    {
        timer->next = head;
        head->prev = timer;
        head = timer;
        return;
    }
    add_timer(timer, head);
}

// 将定时器 timer 从链表中删除
void sort_timer_lst::del_timer(util_timer* timer)
{
    if(!timer)
    {
        return;
    }
    // 链表中只有一个定时器
    if((timer == head) && (timer == tail))
    {
        delete timer;
        head = NULL;
        tail = NULL;
        return;
    }
    // 链表至少有一个定时器, 且头节点恰好是目标定时器
    if(timer == head)
    {
        head = head->next;
        head->prev = NULL;
        delete timer;
        return;
    }
    // 链表至少有一个定时器, 且尾节点恰好是目标定时器
    if(timer == tail)
    {
        tail = tail->prev;
        tail->next = NULL;
        delete timer;
        return;
    }
    // 链表至少有一个定时器, 目标定时器处在链表中间
    timer->prev->next = timer->next;
    timer->next->prev = timer->prev;
    delete timer;
}

// 当某个定时任务发生变化, 调整该定时器在链表中的位置，此函数只考虑定时时间延长的情况，即定时器往链表的后面移动
void sort_timer_lst::adjust_timer(util_timer* timer)
{
    if(!timer)
    {
        return;
    }
    util_timer* tmp = timer->next;
    // 目标定时器在链表的后面，或者定时时长小于后面的，则不动
    if(!tmp || (timer->expire < tmp->expire))
    {
        return;
    }
    // 如果目标定时器是头节点
    if(timer == head)
    {
        head = head->next;
        head->prev = NULL;
        timer->next = NULL;
        add_timer(timer, head);
    }
    // 目标定时器在链表中间，则重新插入到链表中
    else
    {
        timer->prev->next = timer->next;
        timer->next->prev = timer->prev;
        add_timer(timer, timer->next);
    }
}

/* SIGALARM每触发一次就在信号处理函数执行一次tick函数, 以处理链表上的到期任务 */
void sort_timer_lst::tick()
{
    if(!head)
    {
        return;
    }
    printf( "Timer Tick\n" );
    time_t cur = time(NULL); // 获取当前系统的时间
    util_timer* tmp = head;
    // 从头节点依次处理每一个定时器，直到遇到一个尚未定期的定时器
    while(tmp)
    {
        // 每个定时器存的都是绝对时间
        if(cur < tmp->expire)
        {
            break;
        }
        // 调用定时器回调函数，执行定时任务
        tmp->cb_func(tmp->user_data);
        head = tmp->next;
        if(head)
        {
            head->prev = NULL;
        }
        delete tmp;
        tmp = head;
        printf("close client request\n");
    }
}

悦读

道可道，非常道；名可名，非常名。 无名，天地之始，有名，万物之母。 故常无欲，以观其妙，常有欲，以观其徼。 此两者，同出而异名，同谓之玄，玄之又玄，众妙之门。

最新收录
CodeGeeX 插件在 Visual Studio平台适配上线！成为首个适配VS平台的国产智能编程助手
I2C通信
Typescript+React入门
Open Google Earth Engine（OEEL）——哨兵1号数据的黑边去除功能附链接和代码
FreeBSD服务器监控：核心指标解读与应用建议（Snmp）
Linux-互斥锁与条件变量
[WEB]php特性
vim配置文件详解linux,VIM 环境快速配置(Linux)
Redis安装手册
【AI视野·今日CV 计算机视觉论文速览 第252期】Fri, 22 Sep 2023
;