WebServer -- 日志系统（下）

目录

🌼整体思路

🎂基础API

fputs

可变参数宏 __VA_ARGS__

fflush

🚩流程图与日志类定义

流程图

日志类定义

🌼功能实现

生成日志文件 && 判断写入方式

日志分级与分文件

🌼整体思路

日志系统分两部分，

一：单例模式与阻塞队列的定义

二：日志类的定义与使用

这里介绍日志类的定义与使用，具体涉及基础API，流程图与日志类的定义，功能实现

  • 基础API
    描述 fputs，可变参数宏__VA__ARGS__，fflush
  • 流程图与日志类定义
    描述日志系统整体运行流程，介绍日志类的具体定义
  • 功能实现
    结合代码分析同步 / 异步写文件逻辑，分析超行，按天分文件和日志分级的具体实现

🎂基础API

更好的源码阅读体验~

fputs

#include<stdio.h>
int fputs(const char *str, FILE *stream);
  • str，一个数组，包含要写入的   以空字符终止的字符序列
  • stream，指向FILE对象的指针，该FILE对象标识了要被写入字符串的流

可变参数宏 __VA_ARGS__

__VA_ARGS__，可变参数的宏，定义宏时，定义中参数列表的最后一个参数为省略号，实际使用中有时会加##，有时不加

myprintf("CSDN zhanghm1995")
-> printf("CSDN zhanghm1995")
myprintf("CSDN zhanghm1995 is %d years", 2)
-> printf("CSDN zhanghm1995 is %d years", 2)
// 最简单的定义
#define my_print1(...) printf(__VA_ARGS__)

// 搭配va_list的format使用
#define my_print2(format, ...) printf(format, __VA_ARGS__)
#define my_print3(format, ...) printf(format, ##__VA_ARGS__)

__VA_ARGS__ 宏前面加上 ## 的作用：

当可变参数个数为 0，这里的 printf 参数列表中的 ## 回把前面多余的 , 去掉

否则会编译出错

建议用第二种带 ## 的，程序更加健壮

补充解释👇

C++中可变参数宏定义用法实践_c++可变宏-CSDN博客

  1. 处理任意数量的参数：可变参数宏可以接受不定数量的参数，使得宏在调用时可以传入任意数量的参数。

  2. 使用省略号表示：在宏定义中，使用省略号...表示可变数量的参数，这样就可以在宏中处理不确定数量的实参。

  3. 利用递归或辅助函数处理参数：为了处理可变数量的参数，通常会结合使用递归函数或辅助函数来逐个处理每个参数。

  4. 宏展开后形成单一代码块：为避免在宏展开时产生意外的行为，通常在宏定义中使用do...while(0)结构，将宏展开后形成单一的代码块。

  5. 提高代码复用性：通过可变参数宏，可以实现一次宏定义，多处调用，提高代码的复用性和可维护性。

#include <iostream>  // 包含输入输出流库
#include <sstream>   // 包含字符串流库

// 定义一个可变参数宏 PRINT，用于打印任意数量的参数
/*
定义 PRINT 宏，使用反斜杠表示换行继续宏定义
定义宏展开后的代码块开始
创建一个字符串流对象
用辅助函数处理可变参数并将结果存入字符串流
将字符串流中的内容输出到标准输出流
宏展开后的代码块结束，用 do...while(0) 结构避免宏在使用时产生意外的行为
*/
#define PRINT(...) \ 
do { \  
    std::stringstream ss; \  
    print_helper(ss, __VA_ARGS__); \  
    std::cout << ss.str() << std::endl; \  
} while(0)  

// 辅助函数，用于将可变参数格式化为字符串
template <typename T>
void print_arg(std::ostream& os, const T& arg) {  // 辅助函数，将单个参数输出到指定输出流
    os << arg;  // 输出参数到指定输出流
}

// 递归模板函数，将多个参数格式化为字符串
template <typename T, typename... Args>
void print_arg(std::ostream& os, const T& firstArg, const Args&... args) {  // 递归模板函数，处理多个参数的输出
    os << firstArg << " ";  // 输出第一个参数到指定输出流，并添加空格分隔
    print_arg(os, args...);  // 递归调用自身，处理剩余参数
}

// 模板函数，调用递归函数开始处理多个参数
template <typename... Args>
void print_helper(std::ostream& os, const Args&... args) {  // 模板函数，调用递归函数开始处理多个参数
    print_arg(os, args...);  // 调用递归函数开始处理多个参数
}

int main() {
    // 使用 PRINT 宏输出多个参数
    PRINT("Hello, ", "World!");  // 使用 PRINT 宏输出多个参数
    PRINT("The answer is", 42, "and", 3.14);  // 使用 PRINT 宏输出多个参数
    return 0;  // 返回执行成功
}

Hello,  World!
The answer is 42 and 3.14

fflush

#include<stdio.h>
int fflush(FILE *stream);

fflush() 会强迫将 缓冲区 的数据，写回参数 stream 指定的文件中，如果参数 stream 为 NULL，fflush() 会将所有打开的文件数据更新

在使用多个输出函数，连续进行多次输出到控制台时，有可能下一个数据的上一数据还没输出完毕，还在输出缓冲区中时，下一个 printf 就把另一个数据加入输出缓冲区，结果冲掉了原来的数据，出现错误

在 printf() 后加上 fflush(stdout); 强制马上输出到控制台，可以避免上述错误

🚩流程图与日志类定义

流程图

  • 日志文件
    • 局部变量的懒汉模式获取实例
    • 生成日志文件，并判断同步和异步写入方式
  • 同步
    • 判断是否分文件
    • 直接格式化输出内容，将信息写入日志文件
  • 异步
    • 判断是否分文件
    • 格式化输出内容，将内容写入阻塞队列，创建一个写线程，从阻塞队列取出内容写入日志文件

下面的图，是我在这个网站上画的👇 比语雀好用一丢丢

Excalidraw | Hand-drawn look & feel • Collaborative • Secure

日志类定义

通过局部变量的懒汉单例模式，创建日志实例，对其进行初始化生成日志文件后，格式化输出内容，并根据不同的写入方式，完成对应逻辑，写入日志文件

日志类包括以下方法👇

  • 公有的实例获取方法
  • 初始化日志文件方法
  • 异步日志写入方法，内部调用私有异步方法
  • 内容格式化方法
  • 刷新缓冲区
  • ....
class Log
{
public:
    // C++11以后，使用局部变量懒汉不用加锁
    static Log *get_instance() // 获取Log类的唯一实例
    {
        static Log instance; // 静态局部变量，保证线程安全的懒汉单例模式
        return &instance; // 返回实例指针
    }

    // 可选的参数有 日志文件，日志缓冲区大小，最大行数，
    // 和 最长日志条队列
    bool init(const char *file_name, int log_buf_size = 8192,
              int split_lines = 5000000, int max_queue_size = 0); // 初始化日志系统
    
    // 异步写日志公有方法，调用私有方法 async_write_log
    static void *flush_log_thread(void *args) // 刷新日志的线程函数
    {
        // Log类的唯一实例指针
        // 类内访问静态成员，也需要声明作用域 ::
        Log::get_instance()->async_write_log(); // 调用日志实例的异步写日志方法
    }

    // 将输出内容按照标准格式整理
    // ... 表示 可变参数列表
    void write_log(int level, const char *format, ...); // 写日志方法

    // 强制刷新缓冲区
    void flush(void); // 强制刷新日志缓冲

private:
    Log(); // 构造函数
    virtual ~Log(); // 虚析构函数

    // 异步写日志方法
    void *async_write_log() // 异步写日志方法
    {
        string single_log; // 单条日志字符串

        // 从阻塞队列中取出一条日志内容，写入文件
        while (m_log_queue->pop(single_log)) // 从阻塞队列中取出日志
        {
            m_mutex.lock(); // 加锁
            fputs(single_log.c_str(), m_fp); // 将日志内容写入文件
            m_mutex.unlock(); // 解锁
        }
    }

private:
    char dir_name[128]; // 路径名
    char log_name[128]; // log文件名
    int m_split_lines; // 日志最大行数
    int m_log_buf_size; // 日志缓冲区大小
    long long m_count; // 日志行数记录
    int m_today; // 按天分文件，记录当前时间哪一天
    FILE *m_fp; // 打开log的文件指针
    char *m_buf; // 要输出的内容
    block_queue<string> *m_log_queue; // 阻塞队列
    bool m_is_async; // 是否同步标志位
    locker m_mutex; // 同步类
};

// 可变参数宏定义
// 以下，4 个宏定义在其他文件使用，主要用于不同类型的日志输出

// 调试日志输出宏
#define LOG_DEBUG(format, ...) Log::get_instance()->write_log(0, format, __VA_ARGS__)
// 信息日志输出宏
#define LOG_INFO(format, ...) Log::get_instance()->write_log(1, format, __VA_ARGS__)
// 警告日志输出宏
#define LOG_WARN(format, ...) Log::get_instance()->write_log(2, format, __VA_ARGS__)
// 错误日志输出宏
#define LOG_ERROR(format, ...) Log::get_instance()->write_log(3, format, __VA_ARGS__)

#endif

日志类中的方法都不会被其他程序直接调用，末尾的四个可变参数宏，提供了其他程序的调用方法

前述方法对日志等级进行分类，包括DEBUG，INFO，WARN 和 ERROR 四种级别的日志

🌼功能实现

init() 函数实现日志创建，写入方式的判断

write_log() 函数完成写入日志文件中的具体内容，实现  日志分级，分文件，格式化输出内容

生成日志文件 && 判断写入方式

通过单例模式获取唯一的日志类，调用 init() 方法，初始化生成日志文件，服务器启动按当前时刻创建日志，前缀为时间，后缀为自定义 log 文件名，并记录创建日志的时间 day 和 行数 count

写入方式通过初始化时，是否设置队列大小（表示在队列中可以放几条数据）来判断，若队列大小为 0，则为同步，否则为异步

// 异步需要设置阻塞队列的长度，同步不需要设置
bool Log::init(const char *file_name, int log_buf_size,
               int split_lines, int max_queue_size)
{
    // 如果设置了 max_queue_size，则设置为 异步
    if (max_queue_size >= 1) {
        // 设置写入方式 flag
        m_is_async = true;

        // 创建并设置阻塞队列长度
        m_log_queue = new block_queue<string>(max_queue_size);
        pthread_t tid;

        // flush_log_thread 为回调函数，这里表示创建线程异步写日志
        pthread_create(&tid, NULL, flush_log_thread, NULL);
    }

    // 输出内容长度
    m_log_buf_size = log_buf_size;
    m_buf = new char[m_log_buf_size];
    memset(m_buf, '/0', sizeof(m_buf));

    // 日志最大行数
    m_split_lines = split_lines;

    time_t t = time(NULL);  // 获取当前时间
    struct tm *sys_tm = localtime(&t);  // 获取本地时间
    struct tm my_tm = *sys_tm;  // 复制本地时间

    // 从后往前找到第一个 / 的位置
    const char *p = strrchr(file_name, '/');  // 查找最后一个斜杠的位置
    char log_full_name[256] = {0};  // 初始化日志文件名数组

    // 相当于自定义日志名
    // 若输入的文件名没有 /，则直接将时间 + 文件名作为日志名
    if (p == NULL) 
        snprintf(log_full_name, 255, "%d_%02d_%02d_%s",  // 格式化生成日志文件名
                 my_tm.tm_year + 1900, my_tm.tm_mon + 1,
                 my_tm.tm_mday, file_name);
    else {
        // 将 / 的位置向后移动一个位置，然后复制到 logname 中
        // p - file_name + 1 是文件所在路径文件夹的长度
        // dirname 相当于 ./
        strcpy(log_name, p + 1);  // 复制文件名部分
        strncpy(dir_name, file_name, p - file_name + 1);  // 复制路径部分

        // 后面的参数跟 format 有关
        snprintf(log_full_name, 255, "%s%d_%02d_%02d_%s",  // 格式化生成日志文件名
                 dir_name, my_tm.tm_year + 1900, 
                 my_tm.tm_mon + 1, my_tm.tm_mday, log_name);
    }

    m_today = my_tm.tm_mday;  // 记录今天日期

    m_fp = fopen(log_full_name, "a");  // 以追加模式打开日志文件
    if (m_fp == NULL)  // 如果打开文件失败
        return false;

    return true;
}

代码解释👇

这段代码是日志系统的初始化函数，根据传入的参数初始化日志系统

  1. 异步和同步模式选择：

    • 通过判断传入的 max_queue_size 参数是否大于等于1 来确定日志系统是以同步模式还是异步模式运行
    • 如果 max_queue_size 大于等于1，则表示使用异步模式，会创建一个阻塞队列用于存储日志消息，并启动一个线程异步写日志

  2. 日志文件相关设置

    • 初始化日志系统的缓冲区大小为 log_buf_size
    • 设置日志分割的最大行数为 split_lines

  3. 生成日志文件名

    • 获取当前时间 t，并将其转换成本地时间 sys_tm
    • 判断传入的 file_name 是否包含路径分隔符 /，若无则直接以当前日期和传入的文件名作为日志文件名；若有，则从路径中提取出文件名和路径部分
    • 根据日期、文件名和路径信息构建完整的日志文件名 log_full_name

  4. 记录今天的日期

    • 将当天的日期存储在变量 m_today 中，用于后续判断是否需要切换日志文件

  5. 打开日志文件

    • 使用追加模式打开生成的日志文件，如果打开失败则返回 false

日志分级与分文件

日志分级的实现，一般提供 5 种级别👇

  • Debug，调试代码时输出，系统实际运行时一般不使用
  • Warn，这种警告与调试时终端的 warning 类似，同样是调试代码时使用
  • Info，报告系统当前状态，当前执行的流程或接收的信息
  • Error 和 Fatal，输出系统的错误信息

上述方法，会根据开发具体情况改变

TinyWebServer 中，给出了除Fatal外的四种分级，实际使用了 Debug，Info 和 Error

超行，按天分文件 的逻辑具体是👇

  • 日志写入前会判断当前 day 是否为创建日志的时间，行数是否超过最大行限制
    • 若为创建日志时间，写入日志，否则按当前时间创建心 log，更新创建时间和行数
    • 若行数超过最大行限制，在当前日志的末尾加 count / max_lines 为后缀，创建新log

将系统信息格式化后输出，具体为：格式化时间 + 格式化内容

void Log::write_log(int level, const char *format, ...)
{
    struct timeval now = {0, 0};
    gettimeofday(&now, NULL); // 获取当前时间
    time_t t = now.tv_sec; // 获取秒数
    struct tm *sys_tm = localtime(&t); // 转换为本地时间
    struct tm my_tm = *sys_tm; // 复制本地时间
    char s[16] = {0}; // 存储日志级别字符串

    // 日志分级
    switch (level) {
        case 0:
            strcpy(s, "[debug]:"); // 调试级别
            break;
        case 1:
            strcpy(s, "[info]:"); // 信息级别
            break;
        case 2:
            strcpy(s, "[warn]:"); // 警告级别
            break;
        case 3:
            strcpy(s, "[error]:"); // 错误级别
            break;
        case 4:
            strcpy(s, "[fatal]:"); // 致命错误级别
            break;
    } 

    m_mutex.lock(); // 加锁，保证线程安全

    // 更新现有行数
    m_count++;

    // 如果日志不是今天或者写入的日志行数是最大行的倍数
    // m_split_lines 为最大行数
    if (m_today != my_tm.tm_mday || m_count % m_split_lines == 0)
    {
        char new_log[256] = {0}; // 存储新的日志文件名
        fflush(m_fp); // 刷新文件流
        fclose(m_fp); // 关闭文件
        char tail[16] = {0}; // 存储时间部分的字符串

        // 格式化日志名中的时间部分
        snprintf(tail, 16, "%d_%02d_%02d_", my_tm.tm_year + 1900,
                 my_tm.tm_mon + 1, my_tm.tm_mday);

        // 如果时间不是今天，就创建今天的日志，更新 m_today 和 m_count
        if (m_today != my_tm.tm_mday) {
            snprintf(new_log, 255, "%s%s%s", dir_name, tail, log_name);
            m_today = my_tm.tm_mday; // 更新为今天日期
            m_count = 0; // 重置行数为0
        }
        else {
            // 超过最大行，在之前的日志名基础上，加后缀
            // m_count / m_split_lines
            snprintf(new_log, 255, "%s%s%s.%lld", dir_name, tail,
                     log_name, m_count / m_split_lines);
        }
        m_fp = fopen(new_log, "a"); // 打开新的日志文件
    }

    m_mutex.unlock(); // 解锁

    va_list valst; // 创建可变参数列表
    va_start(valst, format); // 初始化可变参数列表

    string log_str; // 存储日志内容的字符串
    m_mutex.lock(); // 加锁

    // 写入内容格式：时间 + 内容
    // 时间格式化
    int n = snprintf(m_buf, 48, "%d-%02d-%02d %02d:%02d:%02d.%06ld %s ",
                     my_tm.tm_year + 1900, my_tm.tm_mon + 1, my_tm.tm_mday,
                     my_tm.tm_hour, my_tm.tm_min, my_tm.tm_sec, now.tv_usec, s);
    
    // 内容格式化
    int m = vsnprintf(m_buf + n, m_log_buf_size - 1, format, valst);
    m_buf[n + m] = '\n'; // 添加换行符
    m_buf[n + m + 1] = '\0'; // 添加字符串终止符

    log_str = m_buf; // 将格式化后的内容存入字符串

    m_mutex.unlock(); // 解锁

    // 若 m_is_async 为 true 表示异步，默认同步
    // 若异步，就将日志信息加入阻塞队列，同步就加锁向文件中写
    if (m_is_async && !m_log_queue->full()) {
        m_log_queue->push(log_str); // 异步写入日志队列
    } else {
        m_mutex.lock(); // 加锁
        fputs(log_str.c_str(), m_fp); // 同步写入日志文件
        m_mutex.unlock(); // 解锁
    }

    va_end(valst); // 结束可变参数列表
}

补充解释

1）

char *strcpy(char *dest, const char *src);

dest表示目标字符串的地址，src表示源字符串的地址。strcpy会把源字符串（src指向的字符串）的内容复制到目标字符串（dest指向的字符串）中，并以'\0'（空字符）作为结束符

上面的代码中，通过strcpy函数将不同日志级别对应的字符串（比如"[debug]:"、"[info]:"）复制到变量s中，以便后续拼接成完整的日志信息

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

追踪Jira中项目成本与工时，更符合国人使用习惯——TimeWise工时管理

追踪Jira中项目成本与工时，更符合国人使用习惯——TimeWise工时管理

近日&#xff0c;龙智联合Atlassian举办的DevSecOps研讨会年终专场“趋势展望与实战探讨&#xff1a;如何打好DevOps基础、赋能创新”在上海圆满落幕。龙智Atlassian技术与顾问咨询团队&#xff0c;以及清晖、JamaSoftware、CloudBees等生态伙伴的嘉宾发表了主题演讲&#xff0…
阅读更多...
ABAP - OOALV 双击事件

ABAP - OOALV 双击事件

OOALV的双击事件通过cl_gui_alv_grid内置事件double_click实现,效果如下图显示 实现步骤&#xff1a;不需要像单击事件那样需要热点 定义一个事件处理类及其操作处理 CLASS cl_event DEFINITION.PUBLIC SECTION.METHODS handle_double_click FOR EVENT double_clickOF cl_gui…
阅读更多...
MyBatis-Plus 快速入门

MyBatis-Plus 快速入门

介绍 j​​​​​MyBatis-Plus (opens new window)&#xff08;简称 MP&#xff09;是一个 MyBatis (opens new window)的增强工具&#xff0c;在 MyBatis 的基础上只做增强不做改变&#xff0c;为简化开发、提高效率而生。 官网&#xff1a;MyBatis-Plus (baomidou.com) 1.…
阅读更多...
UE5 UE4 不同关卡使用Sequence动画

UE5 UE4 不同关卡使用Sequence动画

参考自&#xff1a;关于Datasmith导入流程 | 虚幻引擎文档 (unrealengine.com) 关卡中的Sequence动画序列&#xff0c;包含特定关卡中的Actor的引用。 将同一个Sequcen动画资源放入其他关卡&#xff0c;Sequence无法在新关卡中找到相同的Actor&#xff0c;导致报错。 Sequen…
阅读更多...
成人年龄判断(个人学习笔记黑马学习)

成人年龄判断(个人学习笔记黑马学习)

结合前面学习的input输入语句&#xff0c;完成如下案例: 1.通过input语句&#xff0c;获取键盘输入&#xff0c;为变量age赋值。(注意转换成数字类型) 2.通过if判断是否是成年人&#xff0c;满足条件则输出提示信息&#xff0c;如下&#xff1a; 欢迎来到黑马儿童游乐场&#x…
阅读更多...
上拉电阻与下拉电阻、电容的作用

上拉电阻与下拉电阻、电容的作用

上拉电阻与下拉电阻 在单片机电路中&#xff0c;上拉电阻和下拉电阻都是常见的电路元件&#xff0c;它们在数字电路设计中扮演着重要的角色。它们的作用如下&#xff1a; 1. **上拉电阻**&#xff1a; - **作用**&#xff1a;当一个引脚没有外部信号时&#xff0c;上拉电阻…
阅读更多...
前端css、js、bootstrap、vue2.x、ajax查漏补缺（1）

前端css、js、bootstrap、vue2.x、ajax查漏补缺（1）

学到的总是忘&#xff0c;遇到了就随手过来补一下 1.【JS】innerHTML innerHTML属性允许更改HTML元素的内容可以解析HTML标签 2.【CSS】display: none 设置元素不可见&#xff0c;不占空间&#xff0c;约等于将元素删除一样&#xff0c;只是源代码还存在 3.【CSS】行内样式 4.【…
阅读更多...
加密与安全_深入了解哈希算法

加密与安全_深入了解哈希算法

文章目录 Pre概述哈希碰撞常用的哈希算法Codejava.security.MessageDigestMD5SHA-1SHA-256MessageDigest支持算法 哈希算法的用途彩虹表攻击基本原理攻击过程 防御彩虹表攻击基本原理用途 小结 Pre PKI - 01 散列(Hash)函数 概述 哈希算法&#xff08;Hash&#xff09;又称摘…
阅读更多...
【探索AI】十一 深度学习之第1周：深度学习概述与基础

【探索AI】十一 深度学习之第1周：深度学习概述与基础

深度学习概述与基础 深度学习的发展历史与现状神经网络的基本原理前向传播与反向传播算法常见的激活函数与优化算法深度学习框架&#xff08;如TensorFlow或PyTorch&#xff09;进行基础操作 深度学习的发展历史与现状 深度学习的发展历史可以追溯到上世纪40年代&#xff0c;当…
阅读更多...
H12-821_85

H12-821_85

85.如图所示,三台一层交换机与一台 HUB 互联,交换机均开启 STP 功能,交换机 STP 的桥 ID 设置请参考下图,其它均是默认配置。以下描述中中错误的是哪一选项? A.SWA 的两个端口都为指定端口,处于转发状态。 B.SWC 的 G0/0/1口为 Alternate 端口,处于阻塞状态 C.SWA 的 G0/0/2…
阅读更多...
第二周opencv

第二周opencv

一、边缘检测算子 边缘检测算子是用于检测图像中物体边界的工具。边缘通常表示图像中灰度值或颜色发生显著变化的地方。边缘检测有助于识别图像中的物体形状、轮廓和结构。这些算子通过分析图像的灰度或颜色梯度来确定图像中的边缘。 1、Roberts 算子 通过局部差分计算检测边缘…
阅读更多...
李沐动手学习深度学习——3.2练习

李沐动手学习深度学习——3.2练习

以下是个人理解&#xff0c;希望进行讨论求解。 练习 1. 如果我们将权重初始化为零&#xff0c;会发生什么。算法仍然有效吗&#xff1f; 根据SGD算法公式如上&#xff0c;第一次迭代的值可知w只与b相关&#xff0c;而对于b的迭代更新&#xff0c;只是与b的初始值相关&#x…
阅读更多...
langchain加载模型时出现ConnectionError: (ProtocolError(‘Connection aborted.‘的解决方案

langchain加载模型时出现ConnectionError: (ProtocolError(‘Connection aborted.‘的解决方案

大家好，我是爱编程的喵喵。双985硕士毕业，现担任全栈工程师一职，热衷于将数据思维应用到工作与生活中。从事机器学习以及相关的前后端开发工作。曾在阿里云、科大讯飞、CCF等比赛获得多次Top名次。现为CSDN博客专家、人工智能领域优质创作者。喜欢通过博客创作的方式对所学的…
阅读更多...
使用vue把一周的时间划分为可以选择多个阶段

使用vue把一周的时间划分为可以选择多个阶段

提示&#xff1a;使用vue把一周的时间划分为可以选择多个阶段段&#xff08;亲测有效&#xff09; 一、直接复制以下代码 代码如下&#xff08;示例&#xff09;&#xff1a; <template><div class"byted-weektime" mousedown"dian" mousemove&qu…
阅读更多...
理解计算着色器中glsl语言的内置变量

理解计算着色器中glsl语言的内置变量

概要 本文通过示例的方式&#xff0c;着重解释以下几个内置变量&#xff1a; gl_WorkGroupSizegl_NumWorkGroupsgl_LocalInvocationIDgl_WorkGroupIDgl_GlobalInvocationID 基本概念 局部工作组与工作项 一个3x2x1的局部工作组示例如下&#xff0c;每个小篮格子表示一个工作项…
阅读更多...
Web前端---图层嵌套与层叠三行三列效果

Web前端---图层嵌套与层叠三行三列效果

1.图层的嵌套设计 <!doctype html> <html> <head> <meta charset"utf-8"> <title>图层嵌套</title><style type"text/css">.inline_div{display:inline-block;}#wrap{width400px;height250px;border:2px solid…
阅读更多...
IO多路复用-select模型

IO多路复用-select模型

IO多路复用&#xff08;IO Multiplexing&#xff09;是一种高效的网络编程模型&#xff0c;可以同时监控多个文件描述符&#xff08;包括套接字等&#xff09;&#xff0c;并在有数据可读或可写时进行通知。其中&#xff0c;select模型是最常用和最早引入的一种IO多路复用模型。…
阅读更多...
09-认证-自研微服务框架

09-认证-自研微服务框架

认证 1. 开启https支持 func (e *Engine) RunTLS(addr, certFile, keyFile string) {err : http.ListenAndServeTLS(addr, certFile, keyFile, e.Handler())if err ! nil {log.Fatal(err)} }1.1 测试 证书生成&#xff1a; 安装openssl 网站下载&#xff1a;http://slproweb…
阅读更多...
k8s.gcr.io/pause:3.2镜像丢失解决

k8s.gcr.io/pause:3.2镜像丢失解决

文章目录 前言错误信息临时解决推荐解决onetwo 前言 使用Kubernetes&#xff08;k8s&#xff09;时遇到了镜像拉取的问题&#xff0c;导致Pod沙盒创建失败。错误显示在尝试从k8s.gcr.io拉取pause:3.2镜像时遇到了超时问题&#xff0c;这通常是因为网络问题或者镜像仓库服务器的…
阅读更多...
【Go语言】Go语言中的指针

【Go语言】Go语言中的指针

Go语言中的指针 变量的本质是对一块内存空间的命名&#xff0c;我们可以通过引用变量名来使用这块内存空间存储的值&#xff0c;而指针则是用来指向这些变量值所在内存地址的值。 注&#xff1a;变量值所在内存地址的值不等于该内存地址存储的变量值。 Go语言中&#xff0c;…
阅读更多...
最新文章

Copyright @ 2022~2023