热门标签 | HotTags
当前位置:  开发笔记 > 编程语言 > 正文

深入解析Zebra中的线程机制及其应用

本文详细探讨了Zebra路由软件中的线程机制及其实际应用。通过对Zebra线程模型的深入分析,揭示了其在高效处理网络路由任务中的关键作用。文章还介绍了线程同步与通信机制,以及如何通过优化线程管理提升系统性能。此外,结合具体应用场景,展示了Zebra线程机制在复杂网络环境下的优势和灵活性。
转自:http://blog.chinaunix.net/uid-20608849-id-2103544.html
------------------------------------------
本文系作者原创,欢迎转载!
转载请注明出处:netwalker.blog.chinaunix.net
------------------------------------------
此文并不针对zebra的应用,甚至不是一个架构的分析,只是对于Zebra的一点儿思考。
Zebra 设计得是如此简洁明快。每一种数据结构均对应于一定的应用,它们之间以一种松耦合的方式共存,而多种数据结构组成的功能模块几乎完美的结合在一起,完成了非常复杂的功能。它的设计思想就在于对C语言面向对象式的应用。
虽然很多程序均借鉴面向对象设计方式,但是Zebra的代码风格是易读的,非常易于理解和学习,与此同时,Zebra使用了丰富的数据结构,比如链表、向量、表和队列等,它的松耦合方式使得每一数据结构封装的功能模块很容易被精简剥离出来,以备我们特殊的应用。这就是我写下Think Of ZEBRA非常重要的原因!
1.ZEBRA中的thread

提起thread就会让人想起线程,Linux中的线程被称为pthread,这里的thread不是pthread,因为它只是对线程的应用层模拟。ZEBRA借助自己的thread结构,将所有的事件(比如文件描述的读写事件,定时事件等)和对应的处理函数封装起来,并取名为struct thread。然后这些threads又被装入不同的“线程“链表挂载到名为thread_master的结构中,这样所有的操作只需要面向thead_master。
  1. /* Thread itself. */
  2. struct thread
  3. {
  4.   unsigned char type;        /* thread type */
  5.   struct thread *next;        /* next pointer of the thread */
  6.   struct thread *prev;        /* previous pointer of the thread */
  7.   struct thread_master *master;    /* pointer to the struct thread_master. */
  8.   int (*func) (struct thread *); /* event function */
  9.   void *arg;            /* event argument */
  10.   union {
  11.     int val;            /* second argument of the event. */
  12.     int fd;            /* file descriptor in case of read/write. */
  13.     struct timeval sands;    /* rest of time sands value. */
  14.   } u;
  15.   RUSAGE_T ru;            /* Indepth usage info. */
  16. };

  17. /* Linked list of thread. */
  18. struct thread_list
  19. {
  20.   struct thread *head;
  21.   struct thread *tail;
  22.   int count;
  23. };

  24. /* Master of the theads. */
  25. struct thread_master
  26. {
  27.   struct thread_list read;
  28.   struct thread_list write;
  29.   struct thread_list timer;
  30.   struct thread_list event;
  31.   struct thread_list ready;
  32.   struct thread_list unuse;
  33.   fd_set readfd;
  34.   fd_set writefd;
  35.   fd_set exceptfd;
  36.   unsigned long alloc;
  37. };

thread_master线程管理者维护了6个“线程“队列:read、write、timer、event、ready和unuse。read队列对应于描述符的读事件,write队列对应于描述符的写事件,timer通常为定时事件,event为自定义事件,这些事件需要我们自己在适合的时候触发,并且这类事件不需要对描述符操作,也不需要延时。ready队列通常只是在内部使用,比如read,write或event队列中因事件触发,就会把该”线程”移入ready队列进行统一处理。unuse是在一个”线程”执行完毕后被移入此队列,并且在需要创建一个新的”线程”时,将从该队列中取壳资源,这样就避免了再次申请内存。只有再取不到的情况下才进行新”线程”的内存申请。

 

1.2 线程管理者中的"线程"链表函数


struct thread_list是一个双向链表,对应的操作有:
//添加thread到指定的链表中的尾部
static void thread_list_add (struct thread_list *list, struct thread *thread);
//添加thread到指定的链表中指定的point前部,它在需要对链表进行排序的时候很有用
static void thread_list_add_before (struct thread_list *list, 
   struct thread *point, 
   struct thread *thread);
//在指定的链表中删除制定的thread
static struct thread *thread_list_delete (struct thread_list *list, struct thread *thread);
//释放指定的链表list中所有的thread, m 中的alloc减去释放的"线程"个数
static void thread_list_free (struct thread_master *m, struct thread_list *list);
//移除list中的第一个thread 并返回
static struct thread *thread_trim_head (struct thread_list *list);

 

1.3 thread中的read队列


考虑这样的应用:创建一个socket,并且需要listen在该socket上,然后读取信息,那么使用read队列是不二选择。下面是一个例子,这个例子将对标准输入文件描述符进行处理:

  1. static int do_accept (struct thread *thread)
  2. {
  3. char buf[1024] = "";
  4. int len = 0;
  5.     
  6. len = read(THREAD_FD(thread), buf, 1024);    
  7. printf("len:%d, %s", len, buf);
  8. return 0;
  9. }

  10. int main()
  11. {
  12.     struct thread thread;

  13.     // 创建线程管理者
  14.     struct thread_master *master = thread_master_create();    

  15.     // 创建读线程,读线程处理的描述符是标准输入0,处理函数为do_accept
  16.     thread_add_read(master, do_accept, NULL, fileno(stdin));
  17.     
  18.     // 打印当前线程管理者中的所有线程
  19.     thread_master_debug(master);
  20.     
  21. // thread_fetch select所有的描述符,一旦侦听的描述符需要处理就将对应的”线程”        的地址通过thread返回
  22.     while(thread_fetch(master, &thread))
  23.     {
  24.      // 执行处理函数
  25.        thread_call(&thread);
  26.        thread_master_debug(master);

  27.       // 这里为什么需要再次添加呢?
  28.       thread_add_read(master, do_accept, NULL, fileno(stdin));
  29.       thread_master_debug(master);
  30.     }    
  31.     
  32.     return 0;
  33. }

 

编译执行,得到如下的结果:
// 这里readlist链表中加入了一个"线程",其他链表为空
-----------
readlist  : count [1] head [0x93241d8] tail [0x93241d8] 
writelist : count [0] head [(nil)] tail [(nil)]
timerlist : count [0] head [(nil)] tail [(nil)]
eventlist : count [0] head [(nil)] tail [(nil)]
unuselist : count [0] head [(nil)] tail [(nil)]
total alloc: [1]
-----------
// 输入hello,回车
Hello

// thread_call调用do_accept进行了操作
len:6, hello

// 发现“线程“被移入了unuselist
-----------
readlist  : count [0] head [(nil)] tail [(nil)]
writelist : count [0] head [(nil)] tail [(nil)]
timerlist : count [0] head [(nil)] tail [(nil)]
eventlist : count [0] head [(nil)] tail [(nil)]
unuselist : count [1] head [0x93241d8] tail [0x93241d8]
total alloc: [1]
-----------

//再次调用thread_add_read发现unuselist被清空,并且”线程“再次加入readlist
-----------
readlist  : count [1] head [0x93241d8] tail [0x93241d8]
writelist : count [0] head [(nil)] tail [(nil)]
timerlist : count [0] head [(nil)] tail [(nil)]
eventlist : count [0] head [(nil)] tail [(nil)]
unuselist : count [0] head [(nil)] tail [(nil)]
total alloc: [1]
-----------

1.4 thread_fetch 和thread_process_fd


顾名思义,thread_fetch是用来获取需要执行的线程的,它是整个程序的核心。这里需要对它进行重点的分析。

  1. struct thread *thread_fetch(struct thread_master *m, struct thread *fetch)
  2. {
  3.   int num;
  4.   int ready;
  5.   struct thread *thread;
  6.   fd_set readfd;
  7.   fd_set writefd;
  8.   fd_set exceptfd;
  9.   struct timeval timer_now;
  10.   struct timeval timer_val;
  11.   struct timeval *timer_wait;
  12.   struct timeval timer_nowait;

  13.   timer_nowait.tv_sec = 0;
  14.   timer_nowait.tv_usec = 0;

  15.   while(1)
  16.   {
  17.     /* 最先处理event队列 */
  18.     if((thread = thread_trim_head(&m->event)) != NULL)
  19.             return thread_run(m, thread, fetch);

  20.     /* 接着处理timer队列 */
  21.     gettimeofday(&timer_now, NULL);
  22.     for(thread = m->timer.head; thread; thread = thread->next)
  23.     { 
  24.        /* 所有到时间的线程均将被处理 */
  25.         if(timeval_cmp(timer_now, thread->u.sands) >= 0)
  26.          {
  27.          thread_list_delete(&m->timer, thread);
  28.          return thread_run(m, thread, fetch);
  29.         }
  30.     }

  31.     /* 处理ready中的线程 */
  32.     if((thread = thread_trim_head (&m->ready)) != NULL)
  33.        return thread_run(m, thread, fetch);

  34.     /* Structure copy. */
  35.     readfd = m->readfd;
  36.     writefd = m->writefd;
  37.     exceptfd = m->exceptfd;

  38.     /* Calculate select wait timer. */
  39.     timer_wait = thread_timer_wait(m, &timer_val);
  40.     
  41.     /* 对所有描述符进行listen */
  42.     num = select(FD_SETSIZE, &readfd, &writefd, &exceptfd, timer_wait);
  43.         xprintf("select num:%d\n", num);
  44.     if(num == 0)
  45.             continue;

  46.     if(num < 0)
  47.     {
  48.          if(errno &#61;&#61; EINTR)
  49.          continue;
  50.          return NULL;
  51.     }

  52.       /* 处理read中线程 */
  53.     ready &#61; thread_process_fd(m, &m->read, &readfd, &m->readfd);

  54.       /* 处理 write中线程 */ 
  55.       ready &#61; thread_process_fd(m, &m->write, &writefd, &m->writefd);

  56.       if((thread &#61; thread_trim_head(&m->ready)) !&#61; NULL)
  57.        return thread_run(m, thread, fetch);
  58.   }
  59. }

显然&#xff0c;Zebra中的thread机制并没有真正的优先级&#xff0c;而只是在处理的时候有些处理一些队列。他们的次序是&#xff1a;event、timer、 ready、 read和write。后面代码分析会得出read和write并没有明显的先后&#xff0c;因为它们最终都将被移入ready然后再被依次执行。而select同时收到多个描述符事件的概率是很低的。

 

thread_process_fd对于read和write线程来说是另一个关键的函数。

 

  1. Int thread_process_fd (struct thread_master *m, struct thread_list *list,
  2.          fd_set *fdset, fd_set *mfdset)
  3. {
  4.   struct thread *thread;
  5.   struct thread *next;
  6.   int ready &#61; 0;
  7.   for (thread &#61; list->head; thread; thread &#61; next)
  8.   {
  9.       next &#61; thread->next;
  10.       if (FD_ISSET (THREAD_FD (thread), fdset))
  11.      {
  12.      assert (FD_ISSET (THREAD_FD (thread), mfdset));
  13.      FD_CLR(THREAD_FD (thread), mfdset);
  14.  // 将侦听到的描述符对应的线程移到ready链表中
  15.      thread_list_delete (list, thread);
  16.      thread_list_add (&m->ready, thread);
  17.      thread->type &#61; THREAD_READY;
  18.      ready&#43;&#43;;
  19.     }
  20.     }
  21.   return ready;
  22. }

Thread_process_fd 将侦听到的描述符对应的线程移到ready链表中&#xff0c;并且进行文件描述的清除操作&#xff0c;文件描述符的添加在thread_add_read和thread_add_write中进行。

 

1.5 thread中的其他链表

 


write链表的操作类似于read链表&#xff0c;而event链表是直接操作的。timer链表只是添加对时间的比对操作。
在加入对应的链表时&#xff0c;使用不同的添加函数。
struct thread *
thread_add_read (struct thread_master *m, int (*func) (struct thread *), void *arg, int fd);
struct thread *thread_add_write (struct thread_master *m, int (*func) (struct thread *), void *arg, int fd);
struct thread *thread_add_event (struct thread_master *m, int (*func) (struct thread *), void *arg, int fd);
struct thread *thread_add_timer (struct thread_master *m, int (*func) (struct thread *), void *arg, int fd);

 

1.6 thread 机制中的其他函数

 

//执行thread
void thread_call (struct thread *thread);

//直接创建并执行&#xff0c;m参数可以为NULL
struct thread *thread_execute (struct thread_master *m,
int (*func)(struct thread *),  void *arg,  int val);

//取消一个线程&#xff0c;thread中的master指针不可为空
void thread_cancel (struct thread *thread);

//取消所有event链表中的参数为arg的线程
void thread_cancel_event (struct thread_master *m, void *arg);

//类似于thread_call&#xff0c;区别是thread_call只是执行&#xff0c;不将其加入unuse链表。thread_run执行后会将其加入unuse链表。
struct thread *thread_run (struct thread_master *m, struct thread *thread,  struct thread *fetch);

// 释放m及其中的线程链表
void thread_master_free (struct thread_master *m);

 

1.7 一些时间相关的函数

 

static struct timeval timeval_subtract (struct timeval a, struct timeval b);

static int timeval_cmp (struct timeval a, struct timeval b);
当然也提供了简单的DEBUG函数thread_master_debug。

 

2.对ZEBRA中thread的应用

 

对thread的应用的探讨是最重要的&#xff0c;也是最根本的。ZEBRA的thread机制&#xff0c;模拟了线程&#xff0c;便于平台间的移植&#xff0c;使流水线式的程序编码模块化&#xff0c;结构化。


线程列表间的组合很容易实现状态机的功能。可以自定义应用层通信协议。比如我们定义一个sysstat的远程监控协议。 Client请求Server&#xff0c;请求Code 可以为SYS_MEM,SYS_RUNTIME,SYS_LOG等信息获取动作&#xff0c;也可以是SYS_REBOOT&#xff0c;SYS_SETTIME等动作请求, Server回应这个SYS_MEM等的结果。通常这很简单&#xff0c;但是如果我们需要添加一些步骤&#xff0c;比如用户验证过程呢&#xff1f;


 

  1.               Request Auth
  2. Client-------------------------------->Server
  3.               Response PWD?
  4. Client<--------------------------------Server
  5.               Provide PWD
  6. Client-------------------------------->Server
  7.               Auth Result
  8. Client<--------------------------------Server
  9.               SYS_LOG
  10. Client-------------------------------->Server
  11.               SYS_LOG_INFO
  12. Client<--------------------------------Server

 

再考虑三次认证错误触发黑名单事件&#xff01;状态机就是在处理完上一事件后&#xff0c;添加不同的事件线程。


 

3.对ZEBRA的思考

 

Zebra由Kunihiro Ishiguro开发于15年前&#xff0c;Kunihiro Ishiguro离开了Zebra&#xff0c;而后它的名字被改成了quagga&#xff0c;以至于在因特网上输入Zebra后&#xff0c;你得到只有斑马的注释。Zebra提供了一整套基于TCP/IP网络的路由协议的支持&#xff0c;如RIPv1&#xff0c;RIPv2的&#xff0c;RIPng&#xff0c;OSPFv2&#xff0c;OSPFv3&#xff0c;BGP等&#xff0c;然而它的亮点并不在于此&#xff0c;而在于它对程序架构的组织&#xff0c;你可以容易的剥离它&#xff0c;使他成为专用的cli程序&#xff0c;也已可以轻易的提取其中的一类数据结构&#xff0c;也可以借用他的thread机制实现复杂的状态机。

编码的价值往往不在于写了多少&#xff0c;而在于对他们的组织&#xff01;好的组织体现美好的架构、设计的艺术&#xff0c;可以给人启迪&#xff0c;并在此基础上激发出更多的灵感。如果一个初学者想学习程序设计的架构&#xff0c;无疑选择Zebra是一个明智的选择&#xff0c;你不仅可以学到各种数据结构&#xff0c;基于C的面向对象设计&#xff0c;还有CLI&#xff0c;以及各种网络路由协议&#xff0c;最重要是的Zebra条理清晰&#xff0c;代码紧凑&#xff0c;至少不会让你焦头烂额&#xff01;

如果你不知道代码中的xprintf是怎么一回事&#xff0c;那么看看另一篇文章《一个通用的debug系统 》&#xff01;


推荐阅读
  • 本文介绍了一种算法,用于从一个整数的末尾获取第 K 位数字。如果该位置不存在,则返回 -1。 ... [详细]
  • This pull request aims to optimize the npm install retry time in branch 0.7, reducing delays caused by long timeouts when no network connection is available. ... [详细]
  • 本文档详细介绍了如何使用XIB文件创建和管理具有不同高度的单元格,通过具体的代码示例展示了在iOS开发中实现这一功能的方法。 ... [详细]
  • 本文详细介绍了如何在网站后台配置电子邮件字段的位置、样式及显示选项,以提高用户体验和管理效率。 ... [详细]
  • 本文详细介绍了DOM(文档对象模型)的基本概念、结构及操作方法。DOM作为一种API,允许开发者以编程方式访问HTML和XML文档的结构,实现页面内容的动态修改。 ... [详细]
  • 我有这种ajax$.ajax({type:"POST",url:"bee_sesi_edit.php&# ... [详细]
  • 探讨如何使用PHP从自定义购物车系统向PayPal传递包括增值税在内的订单详情,确保最终支付金额准确无误。 ... [详细]
  • Windows 消息循环是操作系统的一项核心机制,在 Win32 应用程序开发中,通过 WndProc 函数实现消息处理。本文将探讨如何在 C# WinForms 应用程序中自定义 Windows 消息处理,以实现特定功能。 ... [详细]
  • 本文探讨了在Git子模块目录中运行pre-commit时遇到的错误,并提供了一种通过Docker环境解决此问题的方法。 ... [详细]
  • 本文详细介绍了一种利用局域网环境将本地SQL Server数据库备份至另一台计算机的方法。主要步骤包括在目标机器上设置共享文件夹、配置SQL Server以支持备份任务,并通过定时任务实现自动化备份。 ... [详细]
  • 掌握数据库引擎存储过程与系统视图查询:DBA与BI开发者的必备技能
    本文介绍了如何利用数据库引擎存储过程及系统视图查询数据库结构和对象信息,为数据库管理员(DBA)和商业智能(BI)开发人员提供实用的基础知识。文章涵盖了一系列常用的SQL Server存储过程和系统视图,帮助读者快速获取数据库的相关信息。 ... [详细]
  • 本文详细探讨了虚拟化的基本概念,包括服务器虚拟化、网络虚拟化及其在云计算环境中的应用。特别强调了SDN技术在网络虚拟化和云计算中的关键作用,以及网络虚拟化技术如何提升资源利用效率和管理灵活性。 ... [详细]
  • 本问题探讨了如何使用最少数量的雷达站来覆盖海上的所有岛屿。假设海岸线为一条无限长的直线,陆地位于一侧,海洋位于另一侧。每个岛屿视为海洋一侧的一个点,而雷达站则建立在海岸线上,其覆盖范围为固定距离d。 ... [详细]
  • DirectX11教程:利用几何着色器实现简易Billboard
    本文通过实现一个基于几何着色器(Geometry Shader)的Billboard案例,深入探讨DirectX 11中几何着色器的功能与应用。文章详细介绍了如何在顶点着色器中处理顶点数据,并在几何着色器中生成面向摄像机的四边形。 ... [详细]
  • c++:1
    C第一部分介绍基础:c++:-0,本节介绍C中函数使用。##函数###函数调用调用函数需要先声明函数原型嵌套调用:###参数传递在函数被调用时才分配形参的存储单元实参可以是常量、变 ... [详细]
author-avatar
手机用户2502853847
这个家伙很懒,什么也没留下!
PHP1.CN | 中国最专业的PHP中文社区 | DevBox开发工具箱 | json解析格式化 |PHP资讯 | PHP教程 | 数据库技术 | 服务器技术 | 前端开发技术 | PHP框架 | 开发工具 | 在线工具
Copyright © 1998 - 2020 PHP1.CN. All Rights Reserved | 京公网安备 11010802041100号 | 京ICP备19059560号-4 | PHP1.CN 第一PHP社区 版权所有