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

news2024/9/22 23:23:53

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

定时器处理流程

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

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2048365.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Golang基于DTM的分布式事务TCC实战

Golang基于DTM的分布式事务TCC实战

Golang基于DTM的分布式事务SAGA实战-CSDN博客 源代码&#xff1a;https://github.com/Ssummer520/dtm-gin 代码在宿主机运行 docker network:bridge docker安装,安装成功后可以访问http://localhost:36789/ 打开dtm事务web-ui docker run -itd --name dtm -p 36789:36789 -p…
阅读更多...
阿布吞的基础使用——Ubuntu

阿布吞的基础使用——Ubuntu

Ubuntu是Linux系统的发行版&#xff0c;Linux操作系统中比较流行的一个版本&#xff0c;广泛用于个人电脑、服务器和嵌入式设备。今天来简单讲解一下Ubuntu的基础使用。 1. 桌面环境 登录&#xff1a;安装完成后&#xff0c;启动计算机&#xff0c;输入用户名和密码登录到 Ub…
阅读更多...
基于springboot的车辆违章信息管理系统

基于springboot的车辆违章信息管理系统

✍✍计算机编程指导师 ⭐⭐个人介绍&#xff1a;自己非常喜欢研究技术问题&#xff01;专业做Java、Python、微信小程序、安卓、大数据、爬虫、Golang、大屏等实战项目。 ⛽⛽实战项目&#xff1a;有源码或者技术上的问题欢迎在评论区一起讨论交流&#xff01; ⚡⚡ Java实战 |…
阅读更多...
【CMake】学习笔记1

【CMake】学习笔记1

文章目录 1. CMake概述2. 编写一个简单的CMakeLists.txt2.1注释2.1.1 注释行2.1.2 块注释 2.1 只有源文件 3. CMake中set使用set 基本使用set指定使用C标准set指定输出路径 4. 搜索文件 1. CMake概述 CMake 是一个项目构建工具&#xff0c;并且是跨平台的。关于项目构建我们所熟…
阅读更多...
【安全与管理并重】揭秘公司老板如何平衡信任与效率，利用非授权监控软件优化管理！

【安全与管理并重】揭秘公司老板如何平衡信任与效率，利用非授权监控软件优化管理！

企业面临着前所未有的竞争压力&#xff0c;同时还需要确保内部管理的有效性和数据的安全性。如何在信任与效率之间找到平衡点&#xff0c;成为了许多公司老板关注的重点。安企神软件作为一款集数据防泄密、行为监控与流程化管理于一体的综合性解决方案&#xff0c;为企业提供了…
阅读更多...
SpringCloud集成XXL-JOB定时任务

SpringCloud集成XXL-JOB定时任务

项目场景&#xff1a; XXL-JOB是一个分布式任务调度平台&#xff0c;它能够帮助开发者轻松地实现任务的定时执行、任务调度和任务管理 接入步骤 下载XXL-JOB压缩包 链接: xxl-job XXL-JOB做为子模块 将压缩包解压&#xff0c;项目二级新建目录xxl-job&#xff0c;放入目录…
阅读更多...
后端Spring/SpringBoot框架基础介绍

后端Spring/SpringBoot框架基础介绍

1.Spring基础介绍 spring官网&#xff1a;https://spring.io/ 官方对spring的描述&#xff1a;使java更快、更容易、更安全&#xff0c;聚焦于速度、简洁和生产力。并且是全世界最流行的Java框架。 Spring如今已经形成开发生态圈&#xff0c;它提供若干个子项目&#xff0c;每…
阅读更多...
超声波清洗机哪个牌子效果最好？四个可靠的超声波眼镜清洗机品牌推荐

超声波清洗机哪个牌子效果最好？四个可靠的超声波眼镜清洗机品牌推荐

作为一个常年佩戴眼镜的用户&#xff0c;还是养宠家庭&#xff0c;对于眼镜的清洗&#xff0c;一直是倍感困扰的&#xff0c;养宠的家庭&#xff0c;每天镜片上极易沾染灰尘&#xff0c;用眼镜布擦拭真的很容易把镜片刮花。尽管有时候路过眼镜店会进去清洗&#xff0c;但是终归…
阅读更多...
【数学建模】LINGO编程

【数学建模】LINGO编程

LINGO是一种专门用于求解数学规划问题的软件包。由于LINGO执行速度快&#xff0c;易于方便地输入、求解和分析数学规划问题&#xff0c;因此在教学、科研和工业界得到了广泛应用。LINGO主要用于求解线性规划、非线性规划、一次规划和整数规划等问题&#xff0c;也可用于求解一些…
阅读更多...
Next-Key Lock 详解及其在 REPEATABLE READ 隔离级别中的作用

Next-Key Lock 详解及其在 REPEATABLE READ 隔离级别中的作用

Next-Key Lock 是 MySQL InnoDB 引擎中使用的一种锁定机制&#xff0c;专门用于在 REPEATABLE READ 隔离级别下防止幻读&#xff08;Phantom Reads&#xff09;。它结合了行锁&#xff08;Record Lock&#xff09;和间隙锁&#xff08;Gap Lock&#xff09;&#xff0c;能够在高…
阅读更多...
抽卡机小程序，开启全新拆卡乐趣

抽卡机小程序，开启全新拆卡乐趣

近段时间&#xff0c;盲盒卡牌市场异常火爆&#xff0c;最近爆火的“小马宝莉”系列卡牌就深受消费者的喜爱&#xff0c;受到了广泛关注&#xff0c;同时也推动了卡牌市场的快速发展&#xff01;盲盒卡牌拥有隐藏款卡牌和限量款卡牌&#xff0c;具有非常大的收藏价值&#xff0…
阅读更多...
图纸防泄密高招：5款经典的图纸加密软件

图纸防泄密高招：5款经典的图纸加密软件

图纸加密软件是专为保护设计图纸等敏感文件而设计的加密工具&#xff0c;通过先进的加密技术确保文件在传输、存储和使用过程中的安全性。小编试用后发现了5款经典的图纸加密软件。 1. 安企神软件 7天试用https://work.weixin.qq.com/ca/cawcde06a33907e60a 重点介绍&#xf…
阅读更多...
2-68 基于matlab的小波分解子模式和盒维数的车型识别程序

2-68 基于matlab的小波分解子模式和盒维数的车型识别程序

基于matlab的小波分解子模式和盒维数的车型识别程序&#xff0c;可以选择不同车型&#xff0c;包括小车、中车、大车。GUI可视化界面操作&#xff0c;已包括多种图片。程序已调通&#xff0c;可直接运行。 2-68 小波分解子模式和盒维数 - 小红书 (xiaohongshu.com)
阅读更多...
软件工程的核心原则：KISS, DRY, SOLID, YAGNI

软件工程的核心原则：KISS, DRY, SOLID, YAGNI

软件工程的核心原则&#xff1a;KISS, DRY, SOLID, YAGNI — 深入解析与实践指南 引言 在软件开发的广阔领域中&#xff0c;原则和实践是构建高质量、可维护系统的基石。本文将深入探讨四个核心原则&#xff1a;KISS&#xff08;保持简单&#xff0c;愚蠢&#xff09;、DRY&a…
阅读更多...
Element-05.组件-Form表单

Element-05.组件-Form表单

一.Form表单组件 Form表单组件可以定义在Dialog对话框组件中 与Dialog对话框组件中的属性dialogTableVisible相似&#xff0c;dialogFormVisible的默认值也为false&#xff0c;这也说明了Dialog对话框中的Form表单默认是不显示的&#xff0c;只有当绑定的click事件发生后才会将…
阅读更多...
解决麒麟 V10 SP1 升级 Python 后 yum dnf不可用问题

解决麒麟 V10 SP1 升级 Python 后 yum dnf不可用问题

目录 一、前提概要 二、解决办法 1、卸载原有的 python 2、安装 Python 3.7.9 rpm 3、安装一系列 yum 相关 rpm 4、rpm 包下载 一、前提概要 在部署 gaussDB 的时候&#xff0c;安装代理时要求 python 版本满足 3.7.9&#xff0c;但已安装的麒麟 V10 内集成的 python 版…
阅读更多...
探索工业互联网智能赋能智能制造算法综述

探索工业互联网智能赋能智能制造算法综述

概述 文档地址&#xff1a;https://arxiv.org/pdf/2312.16174 源码地址&#xff1a;https://github.com/microsoft/Cream.git 由于激烈的竞争环境和日益增长的个性化定制需求&#xff0c;制造业面临着数字化转型和升级的压力。为我们指明了前进的方向。然而&#xff0c;现有研…
阅读更多...
stable diffusion inapinting（img2img+inpaint/inapint-model）

stable diffusion inapinting（img2img+inpaint/inapint-model）

https://zhuanlan.zhihu.com/p/681250295https://zhuanlan.zhihu.com/p/681250295AIGC专栏4——Stable Diffusion原理解析-inpaint修复图片为例_diffusion inpaint-CSDN博客文章浏览阅读1.7w次，点赞42次，收藏79次。Inpaint是Stable Diffusion中的常用方法，一起简单学习一下。…
阅读更多...
python之pandas （5 画图）

python之pandas （5 画图）

画图 Series画图 import pandas as pd import numpy as np import matplotlib.pyplot as pltdatapd.Series(np.random.randn(1000),indexnp.arange(1000)) #randn生成服从标准正态分布&#xff08;均值为0&#xff0c;标准差为1&#xff09;的随机样本&#xff0c;1000表示10…
阅读更多...
复现YOLOv8语义分割训练自己的数据集

复现YOLOv8语义分割训练自己的数据集

一、YOLOv8源码下载&#xff1a;https://github.com/ultralytics/ultralytics/tree/v8.2.76 我下载的是最新版本8.2.76 接着下载权重 下载源码后解压 二、配置虚拟环境 创建虚拟环境 conda create -n yolov8 python3.9 激活环境 conda activate yolov8 下载pytorch,官网地…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023