程序员经验分享-hwhale

Nginx 队列双向链表结构 ngx_quene_t

2023-11-18

队列链表结构

        队列双向循环链表实现文件：文件：src/core/ngx_queue.h/.c。在 Nginx 的队列实现中，实质就是具有头节点的双向循环链表，这里的双向链表中的节点是没有数据区的，只有两个指向节点的指针。需注意的是队列链表的内存分配不是直接从内存池分配的，即没有进行内存池管理，而是需要我们自己管理内存，所有我们可以指定它在内存池管理或者直接在堆里面进行管理，最好使用内存池进行管理。节点结构定义如下：

  1. /* 队列结构，其实质是具有有头节点的双向循环链表 */  
  2. typedef struct ngx_queue_s  ngx_queue_t;  
  3.   
  4. /* 队列中每个节点结构，只有两个指针，并没有数据区 */  
  5. struct ngx_queue_s {  
  6.     ngx_queue_t  *prev;  
  7.     ngx_queue_t  *next;  
  8. };  

队列链表操作

其基本操作如下：

  1. /* h 为链表结构体 ngx_queue_t 的指针；初始化双链表 */  
  2. ngx_queue_int(h)  
  3.   
  4. /* h 为链表容器结构体 ngx_queue_t 的指针； 判断链表是否为空 */  
  5. ngx_queue_empty(h)  
  6.   
  7. /* h 为链表容器结构体 ngx_queue_t 的指针，x 为插入元素结构体中 ngx_queue_t 成员的指针；将 x 插入到链表头部 */  
  8. ngx_queue_insert_head(h, x)  
  9.   
  10. /* h 为链表容器结构体 ngx_queue_t 的指针，x 为插入元素结构体中 ngx_queue_t 成员的指针。将 x 插入到链表尾部 */  
  11. ngx_queue_insert_tail(h, x)  
  12.   
  13. /* h 为链表容器结构体 ngx_queue_t 的指针。返回链表容器 h 中的第一个元素的 ngx_queue_t 结构体指针 */  
  14. ngx_queue_head(h)  
  15.   
  16. /* h 为链表容器结构体 ngx_queue_t 的指针。返回链表容器 h 中的最后一个元素的 ngx_queue_t 结构体指针 */  
  17. ngx_queue_last(h)  
  18.   
  19. /* h 为链表容器结构体 ngx_queue_t 的指针。返回链表结构体的指针 */  
  20. ngx_queue_sentinel(h)  
  21.   
  22. /* x 为链表容器结构体 ngx_queue_t 的指针。从容器中移除 x 元素 */  
  23. ngx_queue_remove(x)  
  24.   
  25. /* h 为链表容器结构体 ngx_queue_t 的指针。该函数用于拆分链表， 
  26.  * h 是链表容器，而 q 是链表 h 中的一个元素。 
  27.  * 将链表 h 以元素 q 为界拆分成两个链表 h 和 n 
  28.  */  
  29. ngx_queue_split(h, q, n)  
  30.   
  31. /* h 为链表容器结构体 ngx_queue_t 的指针， n为另一个链表容器结构体 ngx_queue_t 的指针 
  32.  * 合并链表，将 n 链表添加到 h 链表的末尾 
  33.  */  
  34. ngx_queue_add(h, n)  
  35.   
  36. /* h 为链表容器结构体 ngx_queue_t 的指针。返回链表中心元素，即第 N/2 + 1 个 */  
  37. ngx_queue_middle(h)  
  38.   
  39. /* h 为链表容器结构体 ngx_queue_t 的指针，cmpfunc 是比较回调函数。使用插入排序对链表进行排序 */  
  40. ngx_queue_sort(h, cmpfunc)  
  41.   
  42. /* q 为链表中某一个元素结构体的 ngx_queue_t 成员的指针。返回 q 元素的下一个元素。*/  
  43. ngx_queue_next(q)  
  44.   
  45. /* q 为链表中某一个元素结构体的 ngx_queue_t 成员的指针。返回 q 元素的上一个元素。*/  
  46. ngx_queue_prev(q)  
  47.   
  48. /* q 为链表中某一个元素结构体的 ngx_queue_t 成员的指针，type 是链表元素的结构体类型名称， 
  49.  * link 是上面这个结构体中 ngx_queue_t 类型的成员名字。返回 q 元素所属结构体的地址 
  50.  */  
  51. ngx_queue_data(q, type, link)  
  52.   
  53. /* q 为链表中某一个元素结构体的 ngx_queue_t 成员的指针，x 为插入元素结构体中 ngx_queue_t 成员的指针 */  
  54. ngx_queue_insert_after(q, x)  

下面是队列链表操作源码的实现：

初始化链表

  1. /* 初始化队列，即节点指针都指向自己，表示为空队列  */  
  2. #define ngx_queue_init(q)                                                     \  
  3.     (q)->prev = q;                                                            \  
  4.     (q)->next = q  
  5.   
  6. /* 判断队列是否为空 */  
  7. #define ngx_queue_empty(h)                                                    \  
  8.     (h == (h)->prev)  

获取指定的队列链表中的节点

  1. /* 获取队列头节点 */  
  2. #define ngx_queue_head(h)                                                     \  
  3.     (h)->next  
  4.   
  5. /* 获取队列尾节点 */  
  6. #define ngx_queue_last(h)                                                     \  
  7.     (h)->prev  
  8.   
  9.   
  10. #define ngx_queue_sentinel(h)                                                 \  
  11.     (h)  
  12.   
  13. /* 获取队列指定节点的下一个节点 */  
  14. #define ngx_queue_next(q)                                                     \  
  15.     (q)->next  
  16.   
  17. /* 获取队列指定节点的前一个节点 */  
  18. #define ngx_queue_prev(q)                                                     \  
  19.     (q)->prev  

插入节点

在头节点之后插入新节点：

  1. /* 在队列头节点的下一节点插入新节点，其中h为头节点，x为新节点 */  
  2. #define ngx_queue_insert_head(h, x)                                           \  
  3.     (x)->next = (h)->next;                                                    \  
  4.     (x)->next->prev = x;                                                      \  
  5.     (x)->prev = h;                                                            \  
  6.     (h)->next = x  

        插入节点比较简单，只是修改指针的指向即可。下图是插入节点的过程： 注意：虚线表示断开连接，实线表示原始连接，破折线表示重新连接，图中的数字与源码步骤相对应。


在尾节点之后插入节点

  1. /* 在队列尾节点之后插入新节点，其中h为尾节点，x为新节点 */  
  2. #define ngx_queue_insert_tail(h, x)                                           \  
  3.     (x)->prev = (h)->prev;                                                    \  
  4.     (x)->prev->next = x;                                                      \  
  5.     (x)->next = h;                                                            \  
  6.     (h)->prev = x  
下图是插入节点的过程：


删除节点

        删除指定的节点，删除节点只是修改相邻节点指针的指向，并没有实际将该节点的内存释放，内存释放必须由我们进行处理。

  1. #if (NGX_DEBUG)  
  2.   
  3. #define ngx_queue_remove(x)                                                   \  
  4.     (x)->next->prev = (x)->prev;                                              \  
  5.     (x)->prev->next = (x)->next;                                              \  
  6.     (x)->prev = NULL;                                                         \  
  7.     (x)->next = NULL  
  8.   
  9. #else  
  10. /* 删除队列指定的节点 */  
  11. #define ngx_queue_remove(x)                                                   \  
  12.     (x)->next->prev = (x)->prev;                                              \  
  13.     (x)->prev->next = (x)->next  
  14.   
  15. #endif  
删除节点过程如下图所示：


拆分链表

  1. /* 拆分队列链表，使其称为两个独立的队列链表； 
  2.  * 其中h是原始队列的头节点，q是原始队列中的一个元素节点，n是新的节点， 
  3.  * 拆分后，原始队列以q为分界，头节点h到q之前的节点作为一个队列（不包括q节点）， 
  4.  * 另一个队列是以n为头节点，以节点q及其之后的节点作为新的队列链表； 
  5.  */  
  6. #define ngx_queue_split(h, q, n)                                              \  
  7.     (n)->prev = (h)->prev;                                                    \  
  8.     (n)->prev->next = n;                                                      \  
  9.     (n)->next = q;                                                            \  
  10.     (h)->prev = (q)->prev;                                                    \  
  11.     (h)->prev->next = h;                                                      \  
  12.     (q)->prev = n;  
       该宏有 3 个参数，h 为队列头(即链表头指针)，将该队列从 q 节点将队列(链表)拆分为两个队列(链表)，q 之后的节点组成的新队列的头节点为 n 。链表拆分过程如下图所示：

合并链表

  1. /* 合并两个队列链表，把n队列链表连接到h队列链表的尾部 */  
  2. #define ngx_queue_add(h, n)                                                   \  
  3.     (h)->prev->next = (n)->next;                                              \  
  4.     (n)->next->prev = (h)->prev;                                              \  
  5.     (h)->prev = (n)->prev;                                                    \  
  6.     (h)->prev->next = h;                                                      \  
  7.     (n)->prev = (n)->next = n;/* 这是我个人增加的语句，若加上该语句，就不会出现头节点n会指向队列链表的节点 */  
其中，h、n分别为两个队列的指针，即头节点指针，该操作将n队列链接在h队列之后。具体操作如下图所示：

获取中间节点

  1. /* 返回队列链表中心元素 */  
  2. ngx_queue_t *  
  3. ngx_queue_middle(ngx_queue_t *queue)  
  4. {  
  5.     ngx_queue_t  *middle, *next;  
  6.   
  7.     /* 获取队列链表头节点 */  
  8.     middle = ngx_queue_head(queue);  
  9.   
  10.     /* 若队列链表的头节点就是尾节点，表示该队列链表只有一个元素 */  
  11.     if (middle == ngx_queue_last(queue)) {  
  12.         return middle;  
  13.     }  
  14.   
  15.     /* next作为临时指针，首先指向队列链表的头节点 */  
  16.     next = ngx_queue_head(queue);  
  17.   
  18.     for ( ;; ) {  
  19.         /* 若队列链表不止一个元素，则等价于middle = middle->next */  
  20.         middle = ngx_queue_next(middle);  
  21.   
  22.         next = ngx_queue_next(next);  
  23.   
  24.         /* 队列链表有偶数个元素 */  
  25.         if (next == ngx_queue_last(queue)) {  
  26.             return middle;  
  27.         }  
  28.   
  29.         next = ngx_queue_next(next);  
  30.   
  31.         /* 队列链表有奇数个元素 */  
  32.         if (next == ngx_queue_last(queue)) {  
  33.             return middle;  
  34.         }  
  35.     }  
  36. }  

链表排序

        队列链表排序采用的是稳定的简单插入排序方法，即从第一个节点开始遍历，依次将当前节点(q)插入前面已经排好序的队列(链表)中，下面程序中，前面已经排好序的队列的尾节点为prev。操作如下：
  1. /* the stable insertion sort */  
  2.   
  3. /* 队列链表排序 */  
  4. void  
  5. ngx_queue_sort(ngx_queue_t *queue,  
  6.     ngx_int_t (*cmp)(const ngx_queue_t *, const ngx_queue_t *))  
  7. {  
  8.     ngx_queue_t  *q, *prev, *next;  
  9.   
  10.     q = ngx_queue_head(queue);  
  11.   
  12.     /* 若队列链表只有一个元素，则直接返回 */  
  13.     if (q == ngx_queue_last(queue)) {  
  14.         return;  
  15.     }  
  16.   
  17.     /* 遍历整个队列链表 */  
  18.     for (q = ngx_queue_next(q); q != ngx_queue_sentinel(queue); q = next) {  
  19.   
  20.         prev = ngx_queue_prev(q);  
  21.         next = ngx_queue_next(q);  
  22.   
  23.         /* 首先把元素节点q独立出来 */  
  24.         ngx_queue_remove(q);  
  25.   
  26.         /* 找到适合q插入的位置 */  
  27.         do {  
  28.             if (cmp(prev, q) <= 0) {  
  29.                 break;  
  30.             }  
  31.   
  32.             prev = ngx_queue_prev(prev);  
  33.   
  34.         } while (prev != ngx_queue_sentinel(queue));  
  35.   
  36.         /* 插入元素节点q */  
  37.         ngx_queue_insert_after(prev, q);  
  38.     }  
  39. }  

获取队列中节点数据地址

        由队列基本结构和以上操作可知，nginx 的队列操作只对链表指针进行简单的修改指向操作，并不负责节点数据空间的分配。因此，用户在使用nginx队列时，要自己定义数据结构并分配空间，且在其中包含一个 ngx_queue_t 的指针或者对象，当需要获取队列节点数据时，使用ngx_queue_data宏，其定义如下：
  1. /* 返回q在所属结构类型的地址，type是链表元素的结构类型 */  
  2. #define ngx_queue_data(q, type, link)                                         \  
  3.     (type *) ((u_char *) q - offsetof(type, link))  
  4. /*  
测试程序：
  1. #include <stdio.h>  
  2. #include "ngx_queue.h"  
  3. #include "ngx_conf_file.h"  
  4. #include "ngx_config.h"  
  5. #include "ngx_palloc.h"  
  6. #include "nginx.h"  
  7. #include "ngx_core.h"  
  8.   
  9. #define MAX     10  
  10. typedef struct Score  
  11. {  
  12.     unsigned int score;  
  13.     ngx_queue_t Que;  
  14. }ngx_queue_score;  
  15. volatile ngx_cycle_t  *ngx_cycle;  
  16.   
  17. void ngx_log_error_core(ngx_uint_t level, ngx_log_t *log, ngx_err_t err,    
  18.             const char *fmt, ...)  
  19. {  
  20. }  
  21.   
  22. ngx_int_t CMP(const ngx_queue_t *x, const ngx_queue_t *y)  
  23. {  
  24.     ngx_queue_score *xinfo = ngx_queue_data(x, ngx_queue_score, Que);  
  25.     ngx_queue_score *yinfo = ngx_queue_data(y, ngx_queue_score, Que);  
  26.   
  27.     return(xinfo->score > yinfo->score);  
  28. }  
  29.   
  30. void print_ngx_queue(ngx_queue_t *queue)  
  31. {  
  32.     ngx_queue_t *q = ngx_queue_head(queue);  
  33.   
  34.     printf("score: ");  
  35.     for( ; q != ngx_queue_sentinel(queue); q = ngx_queue_next(q))  
  36.     {  
  37.         ngx_queue_score *ptr = ngx_queue_data(q, ngx_queue_score, Que);  
  38.         if(ptr != NULL)  
  39.             printf(" %d\t", ptr->score);  
  40.     }  
  41.     printf("\n");  
  42. }  
  43.   
  44. int main()  
  45. {  
  46.     ngx_pool_t *pool;  
  47.     ngx_queue_t *queue;  
  48.     ngx_queue_score *Qscore;  
  49.   
  50.     pool = ngx_create_pool(1024, NULL);  
  51.   
  52.     queue = ngx_palloc(pool, sizeof(ngx_queue_t));  
  53.     ngx_queue_init(queue);  
  54.   
  55.     int i;  
  56.     for(i = 1; i < MAX; i++)  
  57.     {  
  58.         Qscore = (ngx_queue_score*)ngx_palloc(pool, sizeof(ngx_queue_score));  
  59.         Qscore->score = i;  
  60.         ngx_queue_init(&Qscore->Que);  
  61.   
  62.         if(i%2)  
  63.         {  
  64.             ngx_queue_insert_tail(queue, &Qscore->Que);  
  65.         }  
  66.         else  
  67.         {  
  68.             ngx_queue_insert_head(queue, &Qscore->Que);  
  69.         }  
  70.     }  
  71.   
  72.     printf("Before sort: ");  
  73.     print_ngx_queue(queue);  
  74.   
  75.     ngx_queue_sort(queue, CMP);  
  76.   
  77.     printf("After sort: ");  
  78.     print_ngx_queue(queue);  
  79.   
  80.     ngx_destroy_pool(pool);  
  81.     return 0;  
  82.   
  83. }  

输出结果：
[plain] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. $./queue_test   
  2. Before sort: score:  8   6   4   2   1   3   5   7   9    
  3. After sort: score:  1    2   3   4   5   6   7   8   9    

总结

        在 Nginx 的队列链表中，其维护的是指向链表节点的指针，并没有实际的数据区，所有对实际数据的操作需要我们自行操作，队列链表实质是双向循环链表，其操作是双向链表的基本操作。


FROM:  http://blog.csdn.net/chenhanzhun/article/details/42453757
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

编程常用算法

Nginx 队列双向链表结构 ngx_quene_t 的相关文章

  • css 标签默认样式及清除

    标签默认样式及清除 标签默认样式 一些HTML标签在浏览器中会有默认样式 例如 body标签会有margin 8px ul标签会有margin 16px 0 及padding left 40px 当我们在切图软件中进行尺寸或位置测量的时候

  • 在本地jupyter使用其他环境（如：云创）

    接上一篇笔记 1 打开本地cmd 也可以使用x shell 输入命令 ssh L8888 localhost 8888 root 你的IP 此处的IP是远程需要用到的环境的IP 如下图所示 输入命令 enter之后 如下图所示 2 此时 仍

  • 拟合椭圆分开内外两组点集并计算两两之间的距离

    通过拟合椭圆 区分开内外两组点 然后计算两两的距离 from Ransac Process import RANSAC import cv2 import numpy as np import math from operator impo

  • 逻辑漏洞小结之SRC篇（值得收藏，反复看！）

    最近在挖各大src 主要以逻辑漏洞为主 想着总结一下我所知道的一些逻辑漏洞分享一下以及举部分实际的案例展示一下 方便大家理解 主要从两个方面看 业务方面与漏洞方面 接下来就从拿到网站的挖掘步骤进行逐一介绍各个逻辑漏洞 一 业务 注册 1 短

  • 使用matlab中的随机森林进行数据回归预测

    在MATLAB中使用随机森林进行数据回归预测 你可以遵循以下步骤 准备数据集 将你的特征矩阵X和目标变量向量y加载到MATLAB工作空间中 确保X和y的维度匹配 拆分数据集 将数据集划分为训练集和测试集 可以使用cvpartition函数进

  • app毕业设计开题报告基于Uniapp实现的鲜花商城App

    更多项目资源 最下方联系我们 目录 Uniapp项目介绍 资料获取 Uniapp项目介绍 计算机毕业设计安卓App毕设项目之基于APP的鲜花商城 IT实战课堂 哔哩哔哩 bilibili计算机毕业设计安卓App毕设项目之基于APP的鲜花商城

  • 如何 ubuntu下启动/停止/重启MySQL

    如何启动 停止 重启MySQL 一 启动方式 1 使用 service 启动 service mysql start 2 使用 mysqld 脚本启动 etc inint d mysql start 3 使用 safe mysqld 启动

  • 安全保护策略：iOS应用程序代码保护的关键步骤和技巧

    转载 怎么保护苹果手机移动应用程序ios ipa文件中的代码 目录 转载 怎么保护苹果手机移动应用程序ios ipa文件中的代码 代码混淆步骤 1 选择要混淆保护的ipa文件 2 选择要混淆的类名称 3 选择要混淆保护的函数 方法 4 配置

  • [教程]VC++6.0的简单使用

    鉴于许多同学的vc 6 0无法正常使用 并且不会创建工程及文件 还有的同学会遇到一些编译的问题 我在这里做个小教程 1 工具的准备 首先 我把需要的资源给大家 一共就两个文件 一个安装文件 另一个是MSDEV exe 用于替换 链接 htt

  • 解决IDEA每次新建maven工程都要设置目录问题

    使用IDEA每次新建工程时都要设置这三个目录 解决方法 设置好就 了

  • 磁盘数据线接触不良的故障排查

    手头有个小型主机 运行centos 发现工作很不稳定 经常启动不起来 就算启动起来也会在几分钟内出现各种IO错误 可能出现以下几种报错 1 只读文件系统 Read only file system 尝试对磁盘写入的时候可能出现这个错误 2

  • 2 Linux系统高级

    2 Linux系统高级 1 Linux用户与权限 1 1 文件权限概述 Linux操作系统是 多任务多用户 操作系统 每当我们使用用户名登录操作系统时 Linux都会对该用户进行认证 授权审计等操作 操作系统为了识别每个用户 会给每个用户定

  • 大数据开发必备面试题Spark篇合集

    1 Hadoop 和 Spark 的相同点和不同点 Hadoop 底层使用 MapReduce 计算架构 只有 map 和 reduce 两种操作 表达能力比较欠缺 而且在 MR 过程中会重复的读写 hdfs 造成大量的磁盘 io 读写操作

  • [551]python实现Mean Shift算法

    前文介绍的K Means算法需要指定K值 分组数 本文实现的MeanShift聚类算法不需要预先知道聚类的分组数 对聚类的形状也没有限制 为了更好的理解这个算法 本帖使用Python实现Mean Shift算法 MeanShift算法详细介

  • 数字孪生系统：智慧城市数据可视化

    分享几个我觉得很泛用的智慧城市可视化大屏模板 功能齐全且强大 画面美观且酷炫 模板一 智慧城市可视化应用管理平台 整合城市相关数据资源 对公共环境 人员民生 公共安全等领域的核心指标进行态势监测与可视分析 辅助管理者全面掌控城市运行态势 提

  • Mybatis中xml文件的时间段动态查询

    解决办法1 xml特殊字符可以适用转义字符代替 lt lt 小于号 gt gt 大于号

  • pytorch----Target 2 is out of bounds

    问题 多分类网络加了两层全连接后最后输出1类 计算loss时报错Target N is out of bounds 其中的N是正在处理的数据输入的标签 即第几类 是一个 0 类数 1 的整数 最后输出1类与输入的target不符就会报错 解

  • 必读的android 文章- 收藏集 - 掘金

    写给 Android 开发者的混淆使用手册 Android 掘金 本文转自 点击打开链接 毫无疑问 混淆是打包过程中最重要的流程之一 在没有特殊原因的情况下 所有 app 都应该开启混淆 首先 这里说的的混淆其实是包括了代码压缩 代码混淆以

随机推荐

  • 前端常用js插件

    浏览目录 包管理器 加载器 打包工具 测试框架 框架 断言 覆盖率 运行器 QA 工具 MVC 框架和库 基于 Node 的 CMS 框架 模板引擎 Flux 数据可视化 时间轴 编辑器 文件 函数式编程 响应式编程 数据结构 日期 字符串

  • 直联和间联的区别——直连和间连的区别

    直联和间联的区别 直联就是商户直接和银联对接 商户 银联 直联一般商户自己支付手续费 间联就是商户间接和银联对接 商户 第三方支付 银联 间联也要支付 但一般是有人帮你付 直连和间连的区别 直连 指第三方支付直接与商业银行做对接 如果是本行

  • 硬件基础知识

    SPI是串行外设接口 Serial Peripheral Interface 的缩写 是一种高速的 全双工 同步的通信总线 SCLK SCLK是一种有固定周期并与运行无关的信号量 CLK CLK是一种脉冲信号 TDNN 时延神经网络 它的两

  • UE4持续集成打包（Mac脚本自动化打包）

    主要通过RunUAT进行打包 win和mac均可以打包 本次打包实现在Mac环境下 使用 Engine Build BatchFiles RunUAT sh 参考命令格式 参考文献1 RunUAT BuildCookRun project

  • 一些优秀的开源轻量级TCP/IP协议栈

    以下是一些优秀的开源轻量级TCP IP协议栈 它们适用于嵌入式设备和其他资源受限的环境 lwIP lightweight IP lwIP 是一个非常流行的开源 TCP IP 协议栈 它专门为嵌入式系统设计 具有低内存占用和高效率的特点 lw

  • 【小程序】实现经典2048小游戏

    概述 经典小游戏2048 2048小游戏对于逻辑要求还是很有技术含量的 有兴趣的可以看看 详细 以前学习时写的小游戏2048 技术含量还是不错的 有兴趣的可以看看 2048已经封装好了 在主页面直接引入文件可以直接调用 演示图 调用wxml

  • 设计圆和圆柱体

    编写一个完整的Java Application 程序 包含类Circle Cylinder Main 具体要求如下 1 编写类Circle 表示圆形对象 包含以下成员 属性 radius 私有 double型 圆形半径 方法 Circle

  • Python3.X出现AttributeError: module 'urllib' has no attribute 'urlopen'错误

    研究用Python写爬虫 下载一个网页 报错代码如下 import urllib def getHtml url page urllib urlopen url html page read return html html getHtml

  • 导致事务@Transactional失效的5种场景

    一个程序中不可能没有事务 而 Spring 中 事务的实现方式分为两种 编程式事务和声明式事务 又因为编程式事务实现相对麻烦 而声明式事务实现极其简单 所以在日常项目中 我们都会使用声明式事务 Transactional 来实现事务 Tra

  • 英文学术论文写作——模式识别方向(笔记)

    文章目录 文章结构 英文写作tips Latex小技巧 英文学术论文写作经验几乎为0 在老师和师兄们的帮助下 学习到了如何撰写文章 仅限于模式识别方向的 文章结构 文章除去abstract acknowledgment以及reference

  • 深度学习目标检测综述学习

    目录 0 摘要 1 引言 2 背景 2 1 问题描述 2 2 目标检测中的关键挑战 3 数据集以及评价指标 3 1 数据集 1 PASCAL VOC 07 12 2 ILSVRC 3 MS COCO 4 Open Image 3 2 指标

  • vue一行代码实现富文本编辑器

    vue中我们可以使用tinymce第三方组件 第一 我们先将tinymce下载下来 下载链接 https pan baidu com s 15hvafdE7czBM9Wdu5sh9Ow 提取码 kv48 然后引入两个文件到我们项目中 第二部

  • 第十一届蓝桥杯 ——互质（gcd求最大公约数）

    gcd最大公约数 Rudy的博客 CSDN博客 gcdhttps blog csdn net xiaoyue article details 83239172 ops request misc 257B 2522request 255Fid

  • go语言exec包调用shell命令

    工程中需要用到ffmpeg 想直接用exec包调用shell命令 本来以为很简单 结果折腾了一下午 最后查到了解决方案 假如之前执行报错的语句为 cmd exec Command echo helloworld out err cmd Ou

  • 智能时代悄然到来刷脸支付逐渐成为潮流

    随着人脸识别 人工智能 物联网 大数据等前沿技术的迅速发展 智能时代已悄然到来 刷脸支付也逐渐成为一种潮流 如今 刷脸支付愈发常见 除了乘车刷脸 看病刷脸外 值机 安检 登机也都可以刷脸了 机场不用排长队 不用身份证 仅需一张脸即可登机的刷

  • rabbitmq web界面报错 Access refused

    赋予权限就好了 rabbitmqctl set permissions p 当前登录账户的账号

  • 态势感知与态势理解

    几个星期前 我与我的一个机构同事碰面 讨论了最新的备受瞩目的袭击事件 他向我提到了一个新词 态势理解 在USB提案中做了8个月的工作后 我对催吐流行语并不陌生 这个词立即引起了人们的注意 但是由于我一直在讨论几天 所以这个词本身正在赢得信誉

  • 【MLOps】第 2 章 : MLOps中的人

    大家好 我是Sonhhxg 柒 希望你看完之后 能对你有所帮助 不足请指正 共同学习交流 个人主页 Sonhhxg 柒的博客 CSDN博客 欢迎各位 点赞 收藏 留言 系列专栏 机器学习 ML 自然语言处理 NLP 深度学习 DL fore

  • 备战2023蓝桥国赛-传纸条

    题目描述 解析 这道题想了我好久 一开始我是想假如只走一条路线 从 1 1 走到 m n 这种问题该怎么解决呢 针对这种问题我是设了dp k i j 表示走了k步到达 i j 的好心程度之和的最大值 然后根据这个来写出转移方程来计算 后面就

  • Nginx 队列双向链表结构 ngx_quene_t

    队列链表结构 队列双向循环链表实现文件 文件 src core ngx queue h c 在 Nginx 的队列实现中 实质就是具有头节点的双向循环链表 这里的双向链表中的节点是没有数据区的 只有两个指向节点的指针 需注意的是队列链表的内

热门标签