tinyWebServer 学习笔记——三、定时器处理非活跃链接

最新推荐文章于 2024-07-13 20:38:58 发布
最新推荐文章于 2024-07-13 20:38:58 发布
阅读量1.6k 收藏 2
点赞数
分类专栏： 计算机网络 文章标签： 学习 笔记 linux
未经允许禁止转载
本文链接：https://blog.csdn.net/qq_42375636/article/details/130680028
版权

文章目录

一、基础知识

1. 概念

  • 非活跃：指客户端与服务器建立连接后，长时间不交换数据，一直占用服务器端的文件描述符，导致连接资源的浪费；
  • 定时事件：指固定一段时间之后释放某段代码，由该段代码处理一个事件，如从内核事件表删除事件，并关闭文件描述符，释放连接资源；
  • 定时器：指利用结构体或其他形式，将多种定时器事件进行封装，一个定时器用于处理一个事件；
  • 定时器容器：使用某种容器将多个定时器组合起来，便于对定时事件统一管理，本项目中使用升序链表作为容器。
  • SIGALRM 信号：Linux 中提供了三种定时方法，本项目中使用 SIGALRM 信号，即利用 alarm 函数周期性地触发 SIGALRM 信号，信号处理函数利用管道通知主循环，主循环接收到信号后对升序链表上的定时器进行处理，若该段时间内没有数据交换，则关闭连接，释放资源；
  • 信号通知：Linux 下的信号采用异步处理机制，信号处理函数和当前进程是两条不同的执行路线，即当进程收到信号时，操作系统会中断进程，转而进入信号处理函数，完成后再关闭中断：
    • 为避免信号竞态发生，信号处理期间将不会再次触发它，为使信号不被屏蔽太久，信号处理函数需要尽可能快地执行完毕；
    • 当信号处理逻辑较复杂时，信号处理函数仅仅发送信号通知程序主循环，将信号对应的逻辑放在程序主循环中，由主循环执行信号对应的逻辑代码，这样不会导致信号屏蔽太久；
  • 统一事件源：指将信号与其他事件一样被处理，即信号处理函数利用管道将信号传递给主循环，这样信号事件与其他文件描述符都可以通过 epoll 来监测；

2. API

  • sigaction 结构体：记录信号的处理方式，成员如下：
    • void (*sa_handler)(int); ：指向信号处理函数的函数指针；
    • void (*sa_sigaction)(int, siginfo_t*, void*); ：指向信号处理函数的函数指针，三个参数能够获得更详细的信息；
    • sigset_t sa_mask; ：指定信号处理函数执行期间需要屏蔽的信号；
    • int sa_flags; ：指定信号处理的行为：
      • SA_RESTART ：使被信号打断的系统调用自动重新发起；
      • SA_NOCLDSTOP ：使父进程在它子进程暂停或继续运行时不会受到 SIGCHLD 信号；
      • SA_NOCLDWAIT ：使父进程在它子进程退出时不会受到 SIGCHLD 信号，这时子进程如果退出也不会成为僵尸进程；
      • SA_NODEFER ：使对信号的屏蔽无效，即在信号处理函数执行期间仍能发出这个信号；
      • SA_RESETHAND ：信号处理之后重新设置为默认的处理方式；
      • SA_SIGINFO ：使用 sa_sigaction 成员而不是 sa_handler 作为信号处理函数；
    • void (*sa_restorer)(void); ：一般不使用；
  • int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact); ：
    • signum ：标识操作的信号；
    • act ：标识对信号设置新的处理方式；
    • oldact ：标识信号原来的处理方式；
    • 返回值 ：0 表示成功，-1 表示错误；
  • int sigfillset(sigset_t *set); ：用来将参数 set 信号集初始化，然后把所有信号加入到此信号集里；
  • #define SIGALRM 14 ：由 alarm 系统调用产生 timer 时钟信号；
  • #define SIGTERM 15 ：终端发送的终止信号；
  • unsigned int alarm(unsigned int seconds); ：设置信号传送闹钟，即用来设置信号 SIGALRM 在经过参数 seconds 秒数后发送给目前的进程。如果未设置信号 SIGALRM 的处理函数，那么 alarm() 默认处理终止进程；
  • int socketpair(int dimain, int type, int protocol, int sv[2]); ：创建双向管道；
  • ssize_t send(int sockfd, const void *buf, size_t len, int flags); ：当套接字发送缓冲区变满时，send 通常会阻塞，除非套接字设置为非阻塞模式，当缓冲区变满时，返回 EAGAIN 或者 EWOULDBLOCK 错误，此时可以调用 select 函数来监视何时可以发送数据；

3. 信号处理机制

1

流程图 [1]
  • 信号接收：由内核代理接收信号，并将其放入对应进程的信号队列中，同时向进程发送一个中断，使其陷入内核态。此时信号还在队列中，进程尚不知道有信号到来；
  • 信号检测：当发现有新的信号后，对其进行处理：
    • 进程从内核态返回到用户态前进行信号检测；
    • 进程在内核态中，从睡眠状态被唤醒时进行信号检测；
    • 进程陷入内核态后，有两种情况会对信号进行检测；
  • 信号处理：
    • 调用处理函数之前，内核会将当前内核栈的内容备份拷贝到用户栈上，并且修改指令寄存器，将其指向信号处理函数；
    • 进程返回到用户态，执行相应的信号处理函数；
    • 信号处理函数执行完毕后，进程返回内核态，检查是否还有其他信号未处理；
    • 如果所有信号都处理完成，将恢复内核栈（从用户栈拷贝回来），同时修改指令寄存器，将其指向中断前的运行位置，最后回到用户态继续执行进程；

二、代码解析

1. 信号处理函数

// 信号处理函数
void Utils::sig_handler(int sig)
{
    // 为保证函数的可重入性，保留原来的errno
    // 可重入性表示中断后再次进入该函数，环境变量与之前相同，不会丢失数据
    int save_errno = errno;
    int msg = sig;
    // 将信号值从管道写端写入，传输字符类型，而非整型
    send(u_pipefd[1], (char *)&msg, 1, 0);
    // 将原来的errno赋值为当前的errno
    errno = save_errno;
}

// 设置信号函数
void Utils::addsig(int sig, void(handler)(int), bool restart)
{
    // 创建sigaction结构体变量
    struct sigaction sa;
    memset(&sa, '\0', sizeof(sa));

    // 信号处理函数中仅仅发送信号值，不做对应逻辑处理
    sa.sa_handler = handler;
    if (restart)
        sa.sa_flags |= SA_RESTART;

    // 将所有信号添加到信号集中
    sigfillset(&sa.sa_mask);

    // 执行sigaction函数
    assert(sigaction(sig, &sa, NULL) != -1);
}

2. 信号通知逻辑

  • 创建管道；
  • 设置信号处理函数 SIGALRM 和 SIGTERM；
  • 利用 I/O 复用系统监听管道读端文件描述符的可读事件；
  • 信息值传递给主循环，主循环根据接收到的信号值执行目标信号对应的逻辑代码；
//创建管道套接字
ret = socketpair(PF_UNIX, SOCK_STREAM, 0, pipefd);
assert(ret != -1);

//设置管道写端为非阻塞，这样能减少阻塞状态的信号处理函数执行时间
//由于未对非阻塞返回值处理，因此如果阻塞就意味着定时事件失效
setnonblocking(pipefd[1]);

//设置管道读端为ET非阻塞
addfd(epollfd, pipefd[0], false);

//传递给主循环的信号值，这里只关注SIGALRM和SIGTERM
addsig(SIGALRM, sig_handler, false);
addsig(SIGTERM, sig_handler, false);

//循环条件
bool stop_server = false;

//超时标志
bool timeout = false;

//每隔TIMESLOT时间触发SIGALRM信号
alarm(TIMESLOT);

while (!stop_server)
{
    //监测发生事件的文件描述符
    int number = epoll_wait(epollfd, events, MAX_EVENT_NUMBER, -1);
    if (number < 0 && errno != EINTR)
    {
        break;
    }

    //轮询文件描述符
    for (int i = 0; i < number; i++)
    {
        int sockfd = events[i].data.fd;

        //管道读端对应文件描述符发生读事件
        if ((sockfd == pipefd[0]) && (events[i].events & EPOLLIN))
        {
            int sig;
            char signals[1024];

            //从管道读端读出信号值，成功返回字节数，失败返回-1
            //正常情况下，这里的ret返回值总是1，只有14和15两个ASCII码对应的字符
            ret = recv(pipefd[0], signals, sizeof(signals), 0);
            if (ret == -1)
            {
                // handle the error
                continue;
            }
            else if (ret == 0)
            {
                continue;
            }
            else
            {
                //处理信号值对应的逻辑
                for (int i = 0; i < ret; ++i)
                {
                    //传递字符，即ASCII码
                    switch (signals[i])
                    {
                    //这里是整型，对应ASCII码
                    case SIGALRM:
                    {
                        timeout = true;
                        break;
                    }
                    case SIGTERM:
                    {
                        stop_server = true;
                    }
                    }
                }
            }
        }
    }
}

3. 定时器

// 用户数据
struct client_data
{
    // 客户端socket地址
    sockaddr_in address;

    // socket文件描述符
    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;
};

// 定时器回调函数
void cb_func(client_data *user_data)
{
    // 删除非活动连接在socket上的注册事件
    epoll_ctl(Utils::u_epollfd, EPOLL_CTL_DEL, user_data->sockfd, 0);
    assert(user_data);

    // 关闭文件描述符
    close(user_data->sockfd);

    // 减少连接数
    http_conn::m_user_count--;
}

4. 定时器容器

// 升序计时器
class sort_timer_lst
{
public:
    sort_timer_lst();  // 初始化链表
    ~sort_timer_lst(); // 回收链表空间

    // 添加定时器，内部调用私有成员add_timer
    void add_timer(util_timer *timer);

    // 调整定时器，任务发生变化时，调整定时器在链表中的位置
    void adjust_timer(util_timer *timer);

    // 删除计时器
    void del_timer(util_timer *timer);

    // 定时任务处理函数
    void tick();

private:
    // 私有成员，被公有成员add_timer和adjust_time调用
    // 主要用于调整链表内部结点
    void add_timer(util_timer *timer, util_timer *lst_head);
    // 头尾结点
    util_timer *head;
    util_timer *tail;
};

// 初始化链表
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;
    }
}

// 添加定时器，内部调用私有成员add_timer
void sort_timer_lst::add_timer(util_timer *timer)
{
    if (!timer)
    {
        return;
    }
    if (!head)
    {
        head = tail = timer;
        return;
    }
    // 如果新的定时器超时时间小于当前头部结点
    // 直接将当前定时器结点作为头部结点
    if (timer->expire < head->expire)
    {
        timer->next = head;
        head->prev = timer;
        head = timer;
        return;
    }
    // 否则调用私有成员，调整内部结点
    add_timer(timer, head);
}

// 调整定时器，任务发生变化时，调整定时器在链表中的位
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);
    }
}

// 删除计时器
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::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;
    }
    // 遍历完发现，目标定时器需要放到尾结点处
    if (!tmp)
    {
        prev->next = timer;
        timer->prev = prev;
        timer->next = NULL;
        tail = timer;
    }
}

5. 定时任务处理函数

// 计时，并处理到期的计时器
void sort_timer_lst::tick()
{
    if (!head)
    {
        return;
    }
    // 获取当前时间
    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;
    }
}

6. 使用定时器

  • 浏览器与服务器连接时，创建连接对应的定时器，并将该定时器添加到链表上；
  • 处理异常事件时，执行定时事件，服务器关闭连接，并从链表上移除对应的定时器；
  • 处理定时信号时，将定时标志设置为 true ；
  • 处理读事件时，若某连接上发生读事件，将对应定时器向后移动，否则执行定时事件；
  • 处理写事件时，若服务器通过某连接给浏览器发送数据，将对应定时器向后移动，否则执行定时事件。
//定时处理任务，重新定时以不断触发SIGALRM信号
void timer_handler()
{
    timer_lst.tick();
    alarm(TIMESLOT);
}

//创建定时器容器链表
static sort_timer_lst timer_lst;

//创建连接资源数组
client_data *users_timer = new client_data[MAX_FD];

//超时默认为False
bool timeout = false;

//alarm定时触发SIGALRM信号
alarm(TIMESLOT);

while (!stop_server)
{
    int number = epoll_wait(epollfd, events, MAX_EVENT_NUMBER, -1);
    if (number < 0 && errno != EINTR)
    {
        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_addrlength = sizeof(client_address);

            //该连接分配的文件描述符
            int connfd = accept(listenfd, (struct sockaddr *)&client_address, &client_addrlength);

            //初始化该连接对应的连接资源
            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 (events[i].events & (EPOLLRDHUP | EPOLLHUP | EPOLLERR))
        {
            //服务器端关闭连接，移除对应的定时器
            cb_func(&users_timer[sockfd]);

            util_timer *timer = users_timer[sockfd].timer;
            if (timer)
            {
                timer_lst.del_timer(timer);
            }
        }

        //处理定时器信号
        else if ((sockfd == pipefd[0]) && (events[i].events & EPOLLIN))
        {
            //接收到SIGALRM信号，timeout设置为True
        }

        //处理客户连接上接收到的数据
        else if (events[i].events & EPOLLIN)
        {
            //创建定时器临时变量，将该连接对应的定时器取出来
            util_timer *timer = users_timer[sockfd].timer;
            if (users[sockfd].read_once())
            {
                //若监测到读事件，将该事件放入请求队列
                pool->append(users + sockfd);

                //若有数据传输，则将定时器往后延迟3个单位
                //对其在链表上的位置进行调整
                if (timer)
                {
                    time_t cur = time(NULL);
                    timer->expire = cur + 3 * TIMESLOT;
                    timer_lst.adjust_timer(timer);
                }
            }
            else
            {
                //服务器端关闭连接，移除对应的定时器
                cb_func(&users_timer[sockfd]);
                if (timer)
                {
                    timer_lst.del_timer(timer);
                }
            }
        }
       else if (events[i].events & EPOLLOUT)
       {
           util_timer *timer = users_timer[sockfd].timer;
           if (users[sockfd].write())
           {
                //若有数据传输，则将定时器往后延迟3个单位
                //并对新的定时器在链表上的位置进行调整
                if (timer)
                {
                    time_t cur = time(NULL);
                    timer->expire = cur + 3 * TIMESLOT;
                    timer_lst.adjust_timer(timer);
                }
            }
            else
            {
                //服务器端关闭连接，移除对应的定时器
                cb_func(&users_timer[sockfd]);
                if (timer)
                {
                    timer_lst.del_timer(timer);
                }
            }
       }
    }
    //处理定时器为非必须事件，收到信号并不是立马处理
    //完成读写事件后，再进行处理
    if (timeout)
    {
        timer_handler();
        timeout = false;
    }
}

参考文献

[1] 最新版Web服务器项目详解 - 07 定时器处理非活动连接（上）
[2] 最新版Web服务器项目详解 - 08 定时器处理非活动连接（下）

BeZer0
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
TinyWebserver中定时器的具体运行工作过程
weixin_42259204的博客
05-21 394
TinyWebserver中定时器的具体运行工作过程文章主要内容定时器节点类和定时器链表类具体执行过程参考 文章主要内容 在阅读TinyWebserver源码过程中，对于定时器部分具体运行工作过程进行了梳理。需要结合源码观看本篇文章，希望对阅读定时器部分却思路很混乱的同学以帮助。 定时器节点类和定时器链表类 节点类和链表类的具体结构和作用 具体执行过程 （1） 首先使用socketpair创建管道。 （2） 设置写端为非阻塞，是为了减少信号处理的时间，即使定时事件失效也没关系，并不严格。 （3） 设置读端
Web服务器---TinyWebServer代码详细讲解（timer模块）
qq_38872537的博客
01-27 2157
TinyWebServer代码详细讲解（timer模块）基础知识设计思路定时器触发方式定时器的数据结构代码详解 基础知识 非活跃，是指客户端（这里是浏览器）与服务器端建立连接后，长时间不交换数据，一直占用服务器端的文件描述符，导致连接资源的浪费。 定时事件，是指固定一段时间之后触发某段代码，由该段代码处理一个事件，如从内核事件表删除事件，并关闭文件描述符，释放连接资源。 定时器，是指利用结构体或其他形式，将多种定时事件进行封装起来。具体的，这里只涉及一种定时事件，即定期检测非活跃连接，这里将该定时事件与连接
webserver之定时器
暗色光的博客
11-12 2064
前言 此博客记录对于TinyWebServer项目的学习，并根据自己的理解做出些许更改。 原项目地址：https://github.com/qinguoyi/TinyWebServer 定时器 网络程序通常需要处理定时事件，例如定期检测客户连接的活动状态，因为非活跃连接占用了连接资源，需要定期检测释放非活跃连接。通常将定时事件封装为定时器类，然后使用排序链表、时间轮等数据结构管理定时器。 linux提供了三种定时方法， 1.socket选项SO_RCVTIMEO和SO_SNDTIMEO 2.SIGALRM信
从零开始自制实现WebServer（十三）---- 定时器实现踢掉服务器空闲连接功能 让服务器不再被长连接强行霸占
Love 6's Private Blog
04-16 1920
文章目录前引（十三）---- 利用定时器小根堆 实现踢掉服务器空闲连接功能1、 前引 这部分实现起来感觉应该还是挺简单的 毕竟定时器已经实现了 在增加配置后 现在改成6核 12处理器 12GB内存 不敢设置16GB内存 虚拟机设置16GB 那我Windows还用不用内存啦 怕到时候卡死 算了还是省着来 性能明显上升 现在都可以跑到 9w2短链接每秒啦 哈哈 想到之前 不停的failed 属实快心酸的眼泪都要出来了 同样配置情况下 没有测试 linya学长的 还有muduo库 没测试… 之后测试 去和li
从0到服务器开发——TinyWebServer
青玉白露的博客
04-13 1998
从0到服务器开发——TinyWebServer 文章目录**从0到服务器开发——TinyWebServer****前言：****基础知识****什么是web sever？****什么是socket？****IO复用是什么？****什么是多线程？****二、项目学习****代码架构****编译运行****功能细究****三、拔萝带泥****HTTP****HTTP介绍****HTTP处理流程****连接处理****请求报文处理****返回响应报文****Epoll****常用函数****例子****参考资料*
从零开始实现TinyWebServer
Jiangtagong的博客
05-17 5938
从0到服务器开发——TinyWebServer 前言： 修改、完整注释、添加功能的项目代码： https://github.com/white0dew/WebServer 它是个什么项目？——Linux下C++轻量级Web服务器，助力初学者快速实践网络编程，搭建属于自己的服务器。 使用 线程池 + 非阻塞socket + epoll(ET和LT均实现) + 事件处理(Reactor和模拟Proactor均实现) 的并发模型 使用状态机解析HTTP请求报文，支持解析GET和POST请求 访问服务
轻量级web并发服务器——TinyWebServer的学习了解
qq_44184756的博客
05-31 8259
tinyweb是Linux下C++轻量级web服务器，适合新手入门快速实践网络编程，本文旨在结合项目开发者社长（微信公众号：两猿社）的文章以及网上查询的一些资料对该项目的结构和原理等方面进行进一步的理解和掌握
我不生产代码，只是代码的搬运工！超级多的 ——> 第三方
热门推荐
YST的博客
10-24 2万+
我不生产代码，只是代码的搬运工！无意间看到一篇博客里面全是第三方，简直“丧心病狂”，能看到怀疑人生。总有一款适合你. ————————————————&gt; 在掘金上又看到一篇（这篇做了整理 有一些很少用到的蓝牙 陀螺仪 图表等）：https://juejin.im/entry/589591c08d6d81005838f860 1、通过CocoaPods安装 项目名称 项目信息 AFNe...
iOS 第三方库插件和知名博客
she_yufan的博客
08-17 8285
TimLiu-iOS Swift版本点击这里 欢迎加入QQ交流群: 594119878 介绍 这是一个用于iOS开发的各种开源库、开源资料、开源技术等等的索引库. github排名 https://github.com/trending,github搜索：https://github.com/search 使用方法 根据目录关键字搜索，记得包含@，以保证搜索目录关键字的唯一...
STM32学习笔记——通用定时器的PWM介绍及配置
01-06
脉冲宽度调制(PWM)，是英文“Pulse Width Modulation”的缩写，简称脉宽调制，是利用微处理器的数字输出来对模拟电路进行控制的一种非常有效的技术。简单一点，就是对脉冲宽度的控制。 STM32 的定时器除了 TIM6 和 7...
Web前端学习笔记——HTML基础.docx
11-22
Web 前端学习笔记——HTML 基础 本文主要介绍了 Web 前端学习笔记——HTML 基础相关知识点，涵盖了浏览器内核、Web 标准、HTML 语言等方面。 一、浏览器内核 浏览器内核是指浏览器核心引擎，负责解析和渲染网页。...
ESP8266学习笔记（19）——定时器接口使用（RTOS SDK）
01-06
以下为ESP_IDF软件定时器API 用于替代旧SDK中ets_timer软件定时器API。 尽管FreeRTOS提供了软件计时器，但是这些计时器有一些限制： 最大分辨率等于RTOS滴答周期 计时器回调从低优先级任务分派 硬件计时器不受这两个...
Android学习笔记——Menu介绍(三)
01-04
今天继续昨天没有讲完的Menu的学习，主要是Popup Menu的学习。 Popup Menu（弹出式菜单） 弹出式菜单是一种固定在View上的菜单模型。主要用于以下三种情况： 为特定的内容提供溢出风格（overflow-style）的菜单进行...
Lumos学习王佩丰Excel第四讲：排序与选择
Sunshine_XX的博客
07-10 344
自定义排序演示：工资条拆分的演示：如果遇到很长的表，标题只存在于顶端，打印出来观感不好，可以这样做：有些版本的excel复制筛选数据容易把背后隐藏的所有数据都复制上去，这时可选中定位条件的“可见单元格”选项，复制粘贴即可。并排表示且，错排表示或。ctrl+shift+↓+→全选，演示说明：回头学原理，先记住一句话，要想筛选对，条件表头不要对。
Autoware.universe 高效学习第三章 -- 智驾技术务虚会之智驾技术栈讨论 其一
cy1641395022的博客
07-10 676
Autoware.universe 高效学习第三章 -- 智驾技术务虚会之智驾技术栈讨论 其一
ROS基础学习-ROS运行管理
周陽讀書
07-11 741
ROS运行管理。
昇思MindSpore 25天学习打卡营|day20
最新发布
weixin_42036358的博客
07-13 525
生成式对抗网络(Generative Adversarial Networks，GAN)是一种生成式机器学习模型，是近年来复杂分布上无监督学习最具前景的方法之一。最初，GAN由Ian J. Goodfellow于2014年发明，并在论文生成器的任务是生成看起来像训练图像的“假”图像；判别器需要判断从生成器输出的图像是真实的训练图像还是虚假的图像。GAN通过设计生成模型和判别模型这两个模块，使其互相博弈学习产生了相当好的输出。GAN模型的核心在于提出了通过对抗过程来估计生成模型这一全新框架。
Python 学习中什么是异常处理，如何使用 try、except、finally ？
Itmastergo的博客
07-12 685
异常是程序执行过程中发生的非正常事件，这些事件会中断正常的程序指令流。当程序遇到错误时，Python 会抛出一个异常对象，异常对象包含了错误的类型和相关的信息。
STM8学习笔记---定时器输出7路PWM波-综合文档
05-20
本文介绍了STM8单片机中的定时器...以上是本文的主要内容，总结了STM8学习笔记中关于定时器输出7路PWM波的综合文档。通过详细描述定时器的功能和配置方法，希望读者能够理解并掌握在STM8单片机中实现PWM波输出的方法。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

BeZer0

打赏一杯奶茶支持一下作者吧~~

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值