这两天想看看memcached的实现,所以先学习了libevent,使用起来还是比较简单的,其实是对select/poll/kqueue等的封装,学习libevent过程中又遇到了linux下队列的使用,简单分析如下,权当做记录:

libevent中的例子中使用的是FreeBSD下的queue.h,在linux的/usr/include/sys/queue.h也有该头文件,但是是一个缩减版本,而且没有看到queue 的access method,不知道是不是跟我们的linux服务器版本有关,没办法google了一下,找到了FreeBSD 下queue.h的定义,我们看一下tail queue的定义

  1. #define TAILQ_HEAD(name, type)              \
  2. struct name {                       \
  3. struct type *tqh_first; /* first element */ \
  4. struct type **tqh_last; /* addr of last next element */\
  5. }
  6. #define TAILQ_ENTRY(type)                   \
  7. struct {                            \
  8. struct type *tqe_next;  /* next element */      \
  9. struct type **tqe_prev;/* addr of previous next element*/ \
  10. }
  11. #define TAILQ_INIT(head) do {               \
  12. (head)->tqh_first = NULL;                \
  13. (head)->tqh_last = &(head)->tqh_first;        \
  14. } while (0)
  15. #define TAILQ_INSERT_TAIL(head, elm, field) do {        \
  16. (elm)->field.tqe_next = NULL;            \
  17. (elm)->field.tqe_prev = (head)->tqh_last;     \
  18. *(head)->tqh_last = (elm);               \
  19. (head)->tqh_last = &(elm)->field.tqe_next;        \
  20. } while (0)
  21. #define TAILQ_INSERT_BEFORE(listelm, elm, field) do {       \
  22. (elm)->field.tqe_prev = (listelm)->field.tqe_prev;    \
  23. (elm)->field.tqe_next = (listelm);           \
  24. *(listelm)->field.tqe_prev = (elm);          \
  25. (listelm)->field.tqe_prev = &(elm)->field.tqe_next;   \
  26. } while (0)
  27. #define TAILQ_FIRST(head)       ((head)->tqh_first)
  28. #define TAILQ_NEXT(elm, field)      ((elm)->field.tqe_next)
  29. ....

我们就先分析上面的这些定义,先看个应用的例子

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include "queue.h"
  4. struct QUEUE_ITEM{
  5. int value;
  6. TAILQ_ENTRY(QUEUE_ITEM) entries;
  7. };
  8. TAILQ_HEAD(,QUEUE_ITEM) queue_head;
  9. int main(int argc,char **argv){
  10. struct QUEUE_ITEM *item;
  11. struct QUEUE_ITEM *tmp_item;
  12. TAILQ_INIT(&queue_head);
  13. int i=0;
  14. for(i=5;i<10;i+=2){
  15. item=malloc(sizeof(item));
  16. item->value=i;
  17. TAILQ_INSERT_TAIL(&queue_head, item, entries);
  18. }
  19. struct QUEUE_ITEM *ins_item;
  20. ins_item=malloc(sizeof(ins_item));
  21. ins_item->value=100;
  22. TAILQ_INSERT_BEFORE(item,ins_item,entries);
  23. tmp_item=TAILQ_FIRST(&queue_head);
  24. printf("first element is %d\n",tmp_item->value);
  25. tmp_item=TAILQ_NEXT(tmp_item,entries);
  26. printf("next element is %d\n",tmp_item->value);
  27. tmp_item=TAILQ_NEXT(tmp_item,entries);
  28. printf("next element is %d\n",tmp_item->value);
  29. tmp_item=TAILQ_NEXT(tmp_item,entries);
  30. printf("next element is %d\n",tmp_item->value);
  31. }

结果:

  1. first element is 5
  2. next element is 7
  3. next element is 100
  4. next element is 9

分析: 
QUEUE_ITEM 是我们定义的存放在队列里的东东,简单起见只包括一个int值 
TAILQ_ENTRY(QUEUE_ITEM) entries 主要是存放下一个对象和前一个对象的指针,具体见 header 
  
根据头文件进行宏替换后,实际我们声明的是这样的结构:

  1. struct QUEUE_ITEM{
  2. int value;
  3. struct {
  4. struct QUEUE_ITEM *tqe_next;
  5. struct QUEUE_ITEM **tqe_prev;
  6. }entries;
  7. };

TAILQ_HEAD(,QUEUE_ITEM) queue_head; 实际是

  1. struct {
  2. struct QUEUE_ITEM *tqh_first;
  3. struct QUEUE_ITEM **tqh_last;
  4. }queue_head;

接着我们定义了QUEUE_ITEM的两个指针变量item和tmp_item

TAILQ_INIT(&queue_head); 相当于是

  1. do {
  2. (&queue_head)->tqh_first = NULL;
  3. (&queue_head)->tqh_last = &(&queue_head)->tqh_first;
  4. } while (0);

head的初始化如 下图1

接着我们通过循环分配了几个元素,并赋值

  1. TAILQ_INSERT_TAIL(&queue_head, item, entries); 相当于执行
  2. do {
  3. (item)->entries.tqe_next = NULL;
  4. (item)->entries.tqe_prev = (&queue_head)->tqh_last;
  5. *(&queue_head)->tqh_last = (item);
  6. (&queue_head)->tqh_last = &(item)->entries.tqe_next;
  7. } while (0);

也就是我们的循环执行下面代码段,结果分析见图2,3

  1. for(i=5;i<10;i+=2){
  2. item=malloc(sizeof(item));
  3. item->value=i;
  4. do {
  5. (item)->entries.tqe_next = NULL;
  6. //首次执行相当于item->entries.tqe_prev=&(&queue_head)->tqh_first
  7. //以后执行相当于是(item)->entries.tqe_prev=&(前一个item)->entries.tqe_next;
  8. (item)->entries.tqe_prev = (&queue_head)->tqh_last;
  9. //首次执行相当于(&queue_head)->tqh_first=item
  10. //以后执行相当于是(前一个item)->entries.tqe_next=当前item
  11. *(&queue_head)->tqh_last = (item);
  12. (&queue_head)->tqh_last = &(item)->entries.tqe_next;
  13. } while (0);
  14. }
  1. 最终建立的链表结构如图,下面看一下insert操作,经过宏替换后代码如下
  2. struct QUEUE_ITEM *ins_item;
  3. ins_item=malloc(sizeof(ins_item));
  4. ins_item->value=100;
  5. do {
  6. (ins_item)->entries.tqe_prev = (item)->entries.tqe_prev;
  7. (ins_item)->entries.tqe_next = (item);
  8. //这句话体现了TAILQ的特色,tqe_prev是前一个元素的下个元素地址,
  9. //所以正好应该是当前插入item的地址
  10. *(item)->entries.tqe_prev = (ins_item);
  11. (item)->entries.tqe_prev = &(ins_item)->entries.tqe_next;
  12. } while (0);

总结:TAILQ的最大特点就是每个entry的二级指针tqe_prev其存放的是前一个元素的下个元素地址,呵呵,听起来都很拗口 
我现在就是不知道为什么linux的queue.h只有建立tailq的宏定义而缺少所有的access method,初涉linux c编程,请大家指教

附经过宏替换后的所有代码

  1. #include "stdio.h"
  2. #include "stdlib.h"
  3. struct QUEUE_ITEM{
  4. int value;
  5. struct {
  6. struct QUEUE_ITEM *tqe_next;
  7. struct QUEUE_ITEM **tqe_prev;
  8. }entries;
  9. };
  10. struct {
  11. struct QUEUE_ITEM *tqh_first;
  12. struct QUEUE_ITEM **tqh_last;
  13. }queue_head;
  14. int main(int argc,char **argv){
  15. struct QUEUE_ITEM *item;
  16. struct QUEUE_ITEM *tmp_item;
  17. do {
  18. (&queue_head)->tqh_first = NULL;
  19. (&queue_head)->tqh_last = &(&queue_head)->tqh_first;
  20. } while (0);
  21. int i=0;
  22. for(i=5;i<10;i+=2){
  23. item=malloc(sizeof(item));
  24. item->value=i;
  25. do {
  26. (item)->entries.tqe_next = NULL;
  27. //首次执行相当于item->entries.tqe_prev=&(&queue_head)->tqh_first
  28. //以后执行相当于是(item)->entries.tqe_prev=&(前一个item)->entries.tqe_next;
  29. (item)->entries.tqe_prev = (&queue_head)->tqh_last;
  30. //首次执行相当于(&queue_head)->tqh_first=item
  31. //以后执行相当于是(前一个item)->entries.tqe_next=当前item
  32. *(&queue_head)->tqh_last = (item);
  33. (&queue_head)->tqh_last = &(item)->entries.tqe_next;
  34. } while (0);
  35. }
  36. struct QUEUE_ITEM *ins_item;
  37. ins_item=malloc(sizeof(ins_item));
  38. ins_item->value=100;
  39. do {
  40. (ins_item)->entries.tqe_prev = (item)->entries.tqe_prev;
  41. (ins_item)->entries.tqe_next = (item);
  42. *(item)->entries.tqe_prev = (ins_item);
  43. (item)->entries.tqe_prev = &(ins_item)->entries.tqe_next;
  44. } while (0);
  45. tmp_item=((&queue_head)->tqh_first);
  46. printf("first element is %d\n",tmp_item->value);
  47. tmp_item=((tmp_item)->entries.tqe_next);
  48. printf("next element is %d\n",tmp_item->value);
  49. tmp_item=((tmp_item)->entries.tqe_next);
  50. printf("next element is %d\n",tmp_item->value);
  51. tmp_item=((tmp_item)->entries.tqe_next);
  52. printf("next element is %d\n",tmp_item->value);
  53. }

Linux queue.h之TAILQ队列分析的更多相关文章

  1. Linux进程间通信(System V) --- 消息队列

    消息队列 IPC 原理 消息队列是消息的链式队列,如下图为消息队列的模型.整个消息队列有两种类型的数据结构. 1.msqid_ds 消息队列数据结构:描述整个消息队列的属性,主要包括整个消息队列的权限 ...

  2. Linux块设备加密之dm-crypt分析

    相关的分析工作一年前就做完了,一直懒得写下来.现在觉得还是写下来,以来怕自己忘记了,二来可以给大家分享一下自己的研究经验. 这篇文章算是<Device Mapper代码分析>的后续篇,因为 ...

  3. Linux驱动:LCD驱动框架分析

    一直想花时间来整理一下Linux内核LCD驱动,却一直都忙着做其他事情去了,这些天特意抽出时间来整理之前落下的笔记,故事就这样开始了.LCD驱动也是字符设备驱动的一种,框架上相对于字符设备驱动稍微复杂 ...

  4. Linux 进程间通信(posix消息队列 简单)实例

    Linux 进程间通信(posix消息队列 简单)实例 详情见: http://www.linuxidc.com/Linux/2011-10/44828.htm 编译: gcc -o consumer ...

  5. linux list.h 移植

    Linux内核中List链表的实现,对于想进阶的程序员来说,无疑是一个很好的学习机会.内核实现了一个功能十分强大的链表,而且是开源的,用在其他需要的地方岂不是很省事. 一.看List实现前,先补充ty ...

  6. Linux进程调度(3):进程切换分析

     3.调度函数schedule()分析 当kernel/sched.c:sched_tick()执行完,并且时钟中断返回时,就会调用kernel/sched.c:schedule()完成进程切换.我们 ...

  7. Linux内核链表复用实现队列

    有了前面Linux内核复用实现栈的基础,使用相同的思想实现队列,也是非常简单的.普通单链表复用实现队列,总会在出队或入队的时候有一个O(n)复杂度的操作,大多数采用增加两个变量,一个head,一个ta ...

  8. Linux mips64r2 PCI中断路由机制分析

    Linux mips64r2 PCI中断路由机制分析 本文主要分析mips64r2 PCI设备中断路由原理和irq号分配实现方法,并尝试回答如下问题: PCI设备驱动中断注册(request_irq) ...

  9. Linux I2C总线设备驱动模型分析(ov7740)

    1. 框架1.1 硬件协议简介1.2 驱动框架1.3 bus-drv-dev模型及写程序a. 设备的4种构建方法a.1 定义一个i2c_board_info, 里面有:名字, 设备地址 然后i2c_r ...

随机推荐

  1. Python移动自动化测试面试✍✍✍

    Python移动自动化测试面试  整个课程都看完了,这个课程的分享可以往下看,下面有链接,之前做java开发也做了一些年头,也分享下自己看这个视频的感受,单论单个知识点课程本身没问题,大家看的时候可以 ...

  2. java-day18

    函数式接口在java中指:有且仅有一个抽象方法的接口 @FunctionalInterface注解:可以检测接口是否是一个函数式接口 函数式接口的使用:一般可以作为方法的参数和返回值类型 自定义函数式 ...

  3. 【gcc】更新下载编译gcc遇到的各种问题

    帮学长的oj升级gcc版本.遇到了贼多问题.. [悲惨的开始] 安装gcc版本推荐ustc的mirror的下载,超快der... https://mirrors.ustc.edu.cn/gnu/gcc ...

  4. C# 基于创建一个mysql 连接池

    创建一个连接池操作类 using MySql.Data.MySqlClient; using System; using System.Collections.Generic; using Syste ...

  5. Flyway - Version control for your database

    Flyway 是什么? Flyway是个数据库版本管理工具.在开发过程中,数据库难免发生变更,例如数据变更,表结构变更.新建表或者视图等等. 在项目进行时无法保证一旦开发环境中的数据库内容变化候会去测 ...

  6. nginx打包成rpm

    [root@localhost ~ ]#yum -y install lrzsz pcre pcre-devel zlib zlib-devel vim nrt-tools psmisc gcc gc ...

  7. 深度探索C++对象模型读书笔记-第七章站在对象模型的尖端

    Template 模板是在编译时期而非执行时期被计算的.因此其不会带来效率的降低. 1: const Point<float> &ref = 0; 该语句会实例化一个Point的f ...

  8. Python Faker的使用 及 常用函数的查询

    安装faker  pip install faker faker的使用 引用:from faker import Faker 初始化:f=Faker(locale='zh_CN') # 默认是en_U ...

  9. h5 app 设置全屏

    h5 app的全屏和沉浸式状态栏是不一样的 全屏模式 常见使用场景:如果页面是全屏游戏,一般会直接让状态栏消失,也就是页面全屏.webview高度全屏了,状态栏没有了.写法: 终端支持:没有终端类型限 ...

  10. Mybatis3中@SelectProvider传递参数

    一.通常情况下我们使用实体类或者vo类来传递参数,这样可以在provider中直接使用#{param}来获取参数 二.在mybatis3.3以下版本只能传递一个参数,所以如果要传递多个参数必须封装成M ...