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

news/2024/9/22 14:03:18/

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

定时器处理流程

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 -> intint 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 64class 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");}
}

http://www.ppmy.cn/news/1511156.html

相关文章

使用WebStorm进行高效的全栈JavaScript开发

使用WebStorm进行高效的全栈JavaScript开发

使用WebStorm进行高效的全栈JavaScript开发&#xff0c;是一个涉及多方面技能与工具利用的过程。WebStorm&#xff0c;作为JetBrains公司推出的一款专为前端开发者和全栈工程师设计的集成开发环境&#xff08;IDE&#xff09;&#xff0c;以其强大的功能、卓越的性能和友好的用…
阅读更多...
【51单片机】DS1302驱动，11.0592MHZ，使用DS1302

【51单片机】DS1302驱动，11.0592MHZ，使用DS1302

ds1302.h: sbit DS1302_CLK = P3 ^ 6; // 时钟引脚 sbit DS1302_IO = P3 ^ 4; // 数据引脚 sbit DS1302_RST = P3 ^ 5; // 复位引脚#define DS1302_DATA_IO DS1302_IO // 定义DS1302的数据口<
阅读更多...
C++ 线程 一些同步方式

C++ 线程 一些同步方式

C 线程一些同步方式 1.互斥锁&#xff08;Mutex&#xff09;2. 读写锁&#xff08;Reader-Writer Lock&#xff09;3. 信号量&#xff08;Semaphore&#xff09;4. 原子操作&#xff08;Atomic&#xff09;5. 屏障&#xff08;Barrier&#xff09;6. 条件变量&#xff08;Condi…
阅读更多...
ES6-ES13学习笔记

ES6-ES13学习笔记

目录 初识ES6 变量声明 解构赋值 对象解构 ​编辑 数组解构 ​编辑模版字符串 字符串扩展 includes() repeat() startsWith() endsWith() 数值扩展 二进制和八进制表示法 &#xff08;Number.&#xff09;isFinite()与isNaN() Number.isInteger() Math.trunc …
阅读更多...
Spring-MVC 结合 Swagger2

Spring-MVC 结合 Swagger2

目录 一、引入依赖 二、创建Swagger配置类 三、修改Spring-MVC配置文件 四、在游览器打开 五、配置 Swagger 六、使用 Swagger 七、Swagger 的常用注解 ApiOperation() ApiModel ()、ApiModelProperty () 一、引入依赖 <dependency><groupId>io.springf…
阅读更多...
Kotlin之lateinit 和 lazy 区别

Kotlin之lateinit 和 lazy 区别

目录 lateinitlazy区别总结适用范围&#xff1a;初始化时机&#xff1a;线程安全&#xff1a;检查是否初始化&#xff1a;缓存结果&#xff1a;使用场景 在 Kotlin 中&#xff0c;lateinit 和 lazy 都用于延迟初始化变量&#xff0c;但它们有不同的应用场景和使用方式。 latein…
阅读更多...
【机械原理学习】——《机械原理》（第二版）机构部分

【机械原理学习】——《机械原理》（第二版）机构部分

机械原理 绪论&#xff1a; 机械机器机构 第一章&#xff1a;平面机构的结构分析 构件与零件 每个独立运动的单元体称为构件机构总是由一些零件组成的‌过盈配合是指两个配合零件之间存在一定的过盈量&#xff0c;即一个零件的孔径比另一个零件的轴径小&#xff0c;装配时…
阅读更多...
最常用的正则表达式规则和语法

最常用的正则表达式规则和语法

正则表达式（Regular Expression，简称 regex）是一种用于匹配字符串的强大工具。它使用特定的语法规则来定义字符串模式，可以用来搜索、替换、验证字符串等。以下是一些常用的正则表达式规则和语法： 1. 基本字符匹配 . ：匹配任意单个字符（除了换行符）。 示例：a.c 可以匹…
阅读更多...
最新文章

Copyright @ 2022~2023