通用线程：POSIX 线程详解，第 3 部分 使用条件变量提高效率-3

look_w

队列需要队列是出于两个原因。首先，需要队列来保存工作作业。还需要可用于跟踪已终止线程的数据结构。还记得前几篇文章（请参阅本文结尾处的 ）中，我曾提到过需要使用带有特定进程标识的 pthread_join 吗？使用“清除队列”（称作 "cq"）可以解决无法等待        任何已终止线程的问题（稍后将详细讨论这个问题）。以下是标准队列代码。将此代码保存到文件 queue.h 和 queue.c：      
queue.h

1 2 3 4 5 6 7 8 9 10 11 12 13 14

/* queue.h ** Copyright 2000 Daniel Robbins, Gentoo Technologies, Inc. ** Author: Daniel Robbins ** Date: 16 Jun 2000 */ typedef struct node {   struct node *next; } node; typedef struct queue {   node *head, *tail; } queue; void queue_init(queue *myroot); void queue_put(queue *myroot, node *mynode); node *queue_get(queue *myroot);

queue.c

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

/* queue.c ** Copyright 2000 Daniel Robbins, Gentoo Technologies, Inc. ** Author: Daniel Robbins ** Date: 16 Jun 2000 ** ** This set of queue functions was originally thread-aware.  I ** redesigned the code to make this set of queue routines ** thread-ignorant (just a generic, boring yet very fast set of queue ** routines).  Why the change?  Because it makes more sense to have ** the thread support as an optional add-on.  Consider a situation ** where you want to add 5 nodes to the queue.  With the ** thread-enabled version, each call to queue_put() would ** automatically lock and unlock the queue mutex 5 times -- that's a ** lot of unnecessary overhead.  However, by moving the thread stuff ** out of the queue routines, the caller can lock the mutex once at ** the beginning, then insert 5 items, and then unlock at the end. ** Moving the lock/unlock code out of the queue functions allows for ** optimizations that aren't possible otherwise.  It also makes this ** code useful for non-threaded applications. ** ** We can easily thread-enable this data structure by using the ** data_control type defined in control.c and control.h.  */ #include <stdio.h> #include "queue.h" void queue_init(queue *myroot) {   myroot->head=NULL;   myroot->tail=NULL; } void queue_put(queue *myroot,node *mynode) {   mynode->next=NULL;   if (myroot->tail!=NULL)     myroot->tail->next=mynode;   myroot->tail=mynode;   if (myroot->:head==NULL)     myroot->head=mynode; } node *queue_get(queue *myroot) {   //get from root   node *mynode;   mynode=myroot->head;   if (myroot->head!=NULL)     myroot->head=myroot->head->next;   return mynode; }

data_control 代码我编写的并不是线程安全的队列例程，事实上我创建了一个“数据包装”或“控制”结构，它可以是任何线程支持的数据结构。看一下 control.h：
control.h

1 2 3 4 5 6

#include typedef struct data_control {   pthread_mutex_t mutex;   pthread_cond_t cond;   int active; } data_control;

现在您看到了 data_control 结构定义，以下是它的视觉表示：
所使用的 data_control 结构图像中的锁代表互斥对象，它允许对数据结构进行互斥访问。黄色的星代表条件变量，它可以睡眠，直到所讨论的数据结构改变为止。on/off 开关表示整数 "active"，它告诉线程此数据是否是活动的。在代码中，我使用整数 active 作为标志，告诉工作队列何时应该关闭。以下是 control.c：
control.c

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62

/* control.c ** Copyright 2000 Daniel Robbins, Gentoo Technologies, Inc. ** Author: Daniel Robbins ** Date: 16 Jun 2000 ** ** These routines provide an easy way to make any type of ** data-structure thread-aware.  Simply associate a data_control ** structure with the data structure (by creating a new struct, for ** example).  Then, simply lock and unlock the mutex, or ** wait/signal/broadcast on the condition variable in the data_control ** structure as needed. ** ** data_control structs contain an int called "active".  This int is ** intended to be used for a specific kind of multithreaded design, ** where each thread checks the state of "active" every time it locks ** the mutex.  If active is 0, the thread knows that instead of doing ** its normal routine, it should stop itself.  If active is 1, it ** should continue as normal.  So, by setting active to 0, a ** controlling thread can easily inform a thread work crew to shut ** down instead of processing new jobs.  Use the control_activate() ** and control_deactivate() functions, which will also broadcast on ** the data_control struct's condition variable, so that all threads ** stuck in pthread_cond_wait() will wake up, have an opportunity to ** notice the change, and then terminate. */ #include "control.h" int control_init(data_control *mycontrol) {   int mystatus;   if (pthread_mutex_init(&(mycontrol->mutex),NULL))     return 1;   if (pthread_cond_init(&(mycontrol->cond),NULL))     return 1;   mycontrol->active=0;   return 0; } int control_destroy(data_control *mycontrol) {   int mystatus;   if (pthread_cond_destroy(&(mycontrol->cond)))     return 1;   if (pthread_cond_destroy(&(mycontrol->cond)))     return 1;   mycontrol->active=0;   return 0; } int control_activate(data_control *mycontrol) {   int mystatus;   if (pthread_mutex_lock(&(mycontrol->mutex)))     return 0;   mycontrol->active=1;   pthread_mutex_unlock(&(mycontrol->mutex));   pthread_cond_broadcast(&(mycontrol->cond));   return 1; } int control_deactivate(data_control *mycontrol) {   int mystatus;   if (pthread_mutex_lock(&(mycontrol->mutex)))     return 0;   mycontrol->active=0;   pthread_mutex_unlock(&(mycontrol->mutex));   pthread_cond_broadcast(&(mycontrol->cond));   return 1; }