http://blog.csdn.net/xuyanbo2008/article/details/7439936
===================================================
提起thread就会让人想起线程，Linux中的线程被称为pthread，这里的thread 不是pthread，因为它只是对线程的应用层模拟。ZEBRA借助自己的thread结构，将所有的事件（比如文件描述的读写事件，定时事件等）和对应 的处理函数封装起来，并取名为struct thread。然后这些threads又被装入不同的“线程“链表挂载到名为thread_master的结构中，这样所有的操作只需要面向 thead_master。
- /* Thread itself. */
- struct thread
- {
- unsigned char type; /* thread type */
- struct thread *next; /* next pointer of the thread */
- struct thread *prev; /* previous pointer of the thread */
- struct thread_master *master; /* pointer to the struct thread_master. */
- int (*func) (struct thread *); /* event function */
- void *arg; /* event argument */
- union {
- int val; /* second argument of the event. */
- int fd; /* file descriptor in case of read/write. */
- struct timeval sands; /* rest of time sands value. */
- } u;
- RUSAGE_T ru; /* Indepth usage info. */
- };
-
- /* Linked list of thread. */
- struct thread_list
- {
- struct thread *head;
- struct thread *tail;
- int count;
- };
-
- /* Master of the theads. */
- struct thread_master
- {
- struct thread_list read;
- struct thread_list write;
- struct thread_list timer;
- struct thread_list event;
- struct thread_list ready;
- struct thread_list unuse;
- fd_set readfd;
- fd_set writefd;
- fd_set exceptfd;
- unsigned long alloc;
- };
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队列是不二选择。下面是一个例子，这个例子将对标准输入文件描述符进行处理：
- static int do_accept (struct thread *thread)
- {
- char buf[1024] = "";
- int len = 0;
-
- len = read(THREAD_FD(thread), buf, 1024);
- printf("len:%d, %s", len, buf);
- return 0;
- }
-
- int main()
- {
- struct thread thread;
-
- // 创建线程管理者
- struct thread_master *master = thread_master_create();
-
- // 创建读线程，读线程处理的描述符是标准输入0，处理函数为do_accept
- thread_add_read(master, do_accept, NULL, fileno(stdin));
-
- // 打印当前线程管理者中的所有线程
- thread_master_debug(master);
-
- // thread_fetch select所有的描述符，一旦侦听的描述符需要处理就将对应的”线程” 的地址通过thread返回
- while(thread_fetch(master, &thread))
- {
- // 执行处理函数
- thread_call(&thread);
- thread_master_debug(master);
-
- // 这里为什么需要再次添加呢？
- thread_add_read(master, do_accept, NULL, fileno(stdin));
- thread_master_debug(master);
- }
-
- return 0;
- }
编译执行，得到如下的结果：
// 这里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是用来获取需要执行的线程的，它是整个程序的核心。这里需要对它进行重点的分析。
- struct thread *thread_fetch(struct thread_master *m, struct thread *fetch)
- {
- int num;
- int ready;
- struct thread *thread;
- fd_set readfd;
- fd_set writefd;
- fd_set exceptfd;
- struct timeval timer_now;
- struct timeval timer_val;
- struct timeval *timer_wait;
- struct timeval timer_nowait;
-
- timer_nowait.tv_sec = 0;
- timer_nowait.tv_usec = 0;
-
- while(1)
- {
- /* 最先处理event队列 */
- if((thread = thread_trim_head(&m->event)) != NULL)
- return thread_run(m, thread, fetch);
-
- /* 接着处理timer队列 */
- gettimeofday(&timer_now, NULL);
- for(thread = m->timer.head; thread; thread = thread->next)
- {
- /* 所有到时间的线程均将被处理 */
- if(timeval_cmp(timer_now, thread->u.sands) >= 0)
- {
- thread_list_delete(&m->timer, thread);
- return thread_run(m, thread, fetch);
- }
- }
-
- /* 处理ready中的线程 */
- if((thread = thread_trim_head (&m->ready)) != NULL)
- return thread_run(m, thread, fetch);
-
- /* Structure copy. */
- readfd = m->readfd;
- writefd = m->writefd;
- exceptfd = m->exceptfd;
-
- /* Calculate select wait timer. */
- timer_wait = thread_timer_wait(m, &timer_val);
-
- /* 对所有描述符进行listen */
- num = select(FD_SETSIZE, &readfd, &writefd, &exceptfd, timer_wait);
- xprintf("select num:%d\n", num);
- if(num == 0)
- continue;
-
- if(num < 0)
- {
- if(errno == EINTR)
- continue;
- return NULL;
- }
-
- /* 处理read中线程 */
- ready = thread_process_fd(m, &m->read, &readfd, &m->readfd);
-
- /* 处理 write中线程 */
- ready = thread_process_fd(m, &m->write, &writefd, &m->writefd);
-
- if((thread = thread_trim_head(&m->ready)) != NULL)
- return thread_run(m, thread, fetch);
- }
- }
显然，Zebra中的thread机制并没有真正的优先级，而只是在处理的时候有些处理一些队列。他们的次序是：event、timer、 ready、 read和write。后面代码分析会得出read和write并没有明显的先后，因为它们最终都将被移入ready然后再被依次执行。而select同 时收到多个描述符事件的概率是很低的。
thread_process_fd对于read和write线程来说是另一个关键的函数。
- Int thread_process_fd (struct thread_master *m, struct thread_list *list,
- fd_set *fdset, fd_set *mfdset)
- {
- struct thread *thread;
- struct thread *next;
- int ready = 0;
- for (thread = list->head; thread; thread = next)
- {
- next = thread->next;
- if (FD_ISSET (THREAD_FD (thread), fdset))
- {
- assert (FD_ISSET (THREAD_FD (thread), mfdset));
- FD_CLR(THREAD_FD (thread), mfdset);
- // 将侦听到的描述符对应的线程移到ready链表中
- thread_list_delete (list, thread);
- thread_list_add (&m->ready, thread);
- thread->type = THREAD_READY;
- ready++;
- }
- }
- return ready;
- }
Thread_process_fd 将侦听到的描述符对应的线程移到ready链表中，并且进行文件描述的清除操作，文件描述符的添加在thread_add_read和thread_add_write中进行。
1.5 thread中的其他链表
write链表的操作类似于read链表，而event链表是直接操作的。timer链表只是添加对时间的比对操作。
在加入对应的链表时，使用不同的添加函数。
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);
//直接创建并执行，m参数可以为NULL
struct thread *thread_execute (struct thread_master *m,
int (*func)(struct thread *), void *arg, int val);
//取消一个线程，thread中的master指针不可为空
void thread_cancel (struct thread *thread);
//取消所有event链表中的参数为arg的线程
void thread_cancel_event (struct thread_master *m, void *arg);
//类似于thread_call，区别是thread_call只是执行，不将其加入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的应用的探讨是最重要的，也是最根本的。ZEBRA的thread机制，模拟了线程，便于平台间的移植，使流水线式的程序编码模块化，结构化。
线程列表间的组合很容易实现状态机的功能。可以自定义应用层通信协议。比如我们定义一个sysstat的远程监控协议。 Client请求Server，请求Code 可以为SYS_MEM,SYS_RUNTIME,SYS_LOG等信息获取动作，也可以是SYS_REBOOT，SYS_SETTIME等动作请求, Server回应这个SYS_MEM等的结果。通常这很简单，但是如果我们需要添加一些步骤，比如用户验证过程呢？
- Request Auth
- Client-------------------------------->Server
- Response PWD?
- Client<--------------------------------Server
- Provide PWD
- Client-------------------------------->Server
- Auth Result
- Client<--------------------------------Server
- SYS_LOG
- Client-------------------------------->Server
- SYS_LOG_INFO
- Client<--------------------------------Server
再考虑三次认证错误触发黑名单事件！状态机就是在处理完上一事件后，添加不同的事件线程。
3.对ZEBRA的思考
Zebra由Kunihiro Ishiguro开发于15年前，Kunihiro Ishiguro离开了Zebra，而后它的名字被改成了quagga，以至于在因特网上输入Zebra后，你得到只有斑马的注释。Zebra提供了一整 套基于TCP/IP网络的路由协议的支持，如RIPv1，RIPv2的，RIPng，OSPFv2，OSPFv3，BGP等，然而它的亮点并不在于此，而 在于它对程序架构的组织，你可以容易的剥离它，使他成为专用的cli程序，也已可以轻易的提取其中的一类数据结构，也可以借用他的thread机制实现复 杂的状态机。
编码的价值往往不在于写了多少，而在于对他们的组织！好的组织体现美好的架构、设计的艺术，可以给人启迪，并在此基础上激发出更多的灵感。如果一个 初学者想学习程序设计的架构，无疑选择Zebra是一个明智的选择，你不仅可以学到各种数据结构，基于C的面向对象设计，还有CLI，以及各种网络路由协 议，最重要是的Zebra条理清晰，代码紧凑，至少不会让你焦头烂额！
如果你不知道代码中的xprintf是怎么一回事，那么看看另一篇文章《一个通用的debug系统 》！
扫一扫
270
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
