POSIX 執行緒詳解(3) (轉)

等待
一旦初始化了互斥物件和條件變數，就可以等待某個條件，如下所示：

pthread_cond_wait(&mycond, &mymutex);

請注意，程式碼在邏輯上應該包含 mycond 和 mymutex。一個特定條件只能有一個互斥物件，而且條件變數應該表示互斥資料“內部”的一種特殊的條件更改。一個互斥物件可以用許多條件變數（例如，cond_empty、cond_full、cond_cleanup），但每個條件變數只能有一個互斥物件。

傳送訊號和廣播
對於傳送訊號和廣播，需要注意一點。如果執行緒更改某些共享資料，而且它想要喚醒所有正在等待的執行緒，則應使用 pthread_cond_broadcast 呼叫，如下所示：

pthread_cond_broadcast(&mycond);

在某些情況下，活動執行緒只需要喚醒第一個正在睡眠的執行緒。假設您只對佇列新增了一個工作作業。那麼只需要喚醒一個工作程式執行緒（再喚醒其它執行緒是不禮貌的！）：

pthread_cond_signal(&mycond);

此函式只喚醒一個執行緒。如果 POSIX 執行緒標準允許指定一個整數，可以讓您喚醒一定數量的正在睡眠的執行緒，那就更完美了。但是很可惜，我沒有被邀請參加會議。

工作組
我將演示如何建立多執行緒工作組。在這個方案中，我們建立了許多工作程式執行緒。每個執行緒都會檢查 wq（“工作佇列”），檢視是否有需要完成的工作。如果有需要完成的工作，那麼執行緒將從佇列中除去一個節點，執行這些特定工作，然後等待新的工作到達。

與此同時，主執行緒負責建立這些工作程式執行緒、將工作新增到佇列，然後在它退出時收集所有工作程式執行緒。您將會遇到許多 C 程式碼，好好準備吧！

data_control 程式碼
我編寫的並不是執行緒安全的佇列例程，事實上我建立了一個“資料包裝”或“控制”結構，它可以是任何執行緒支援的資料結構。看一下 control.h：

control.h

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

現在您看到了 data_control 結構定義，以下是它的視覺表示：

-7-171424251.gif" border=0 valign="TOP">

工作組程式碼
說到工作組程式碼，以下就是：

workcrew.c

#include #include #include "control.h" #include "queue.h" #include "dbug.h" /* the work_queue holds tasks for the various threads to complete. */ struct work_queue { data_control control; queue work; } wq; /* I added a job number to the work node. Normally, the work node would contain additional data that needed to be processed. */ typedef struct work_node { struct node *next; int jobnum; } wnode; /* the cleanup queue holds stopped threads. Before a thread terminates, it adds itself to this list. Since the main thread is waiting for changes in this list, it will then wake up and clean up the newly terminated thread. */ struct cleanup_queue { data_control control; queue cleanup; } cq; /* I added a thread number (for debugging/instructional purposes) and a thread id to the cleanup node. The cleanup node gets passed to the new thread on startup, and just before the thread stops, it attaches the cleanup node to the cleanup queue. The main thread monitors the cleanup queue and is the one that performs the necessary cleanup. */ typedef struct cleanup_node { struct node *next; int threadnum; pthread_t tid; } cnode; void *threadfunc(void *myarg) { wnode *mywork; cnode *mynode; mynode=(cnode *) myarg; pthread_mutex_lock(&wq.control.mutex); while (wq.control.active) { while (wq.work.head==NULL && wq.control.active) { pthread_cond_wait(&wq.control.cond, &wq.control.mutex); } if (!wq.control.active) break; //we got something! mywork=(wnode *) queue_get(&wq.work); pthread_mutex_unlock(&wq.control.mutex); //perform processing... printf("Thread number %d processing job %dn",mynode->threadnum,mywork->jobnum); free(mywork); pthread_mutex_lock(&wq.control.mutex); } pthread_mutex_unlock(&wq.control.mutex); pthread_mutex_lock(&cq.control.mutex); queue_put(&cq.cleanup,(node *) mynode); pthread_mutex_unlock(&cq.control.mutex); pthread_cond_signal(&cq.control.cond); printf("thread %d shutting down...n",mynode->threadnum); return NULL; } #define NUM_WORKERS 4 int numthreads; void join_threads(void) { cnode *curnode; printf("joining threads...n"); while (numthreads) { pthread_mutex_lock(&cq.control.mutex); /* below, we sleep until there really is a new cleanup node. This takes care of any false wakeups... even if we break out of pthread_cond_wait(), we don't make any assumptions that the condition we were waiting for is true. */ while (cq.cleanup.head==NULL) { pthread_cond_wait(&cq.control.cond,&cq.control.mutex); } /* at this point, we hold the mutex and there is an item in the list that we need to process. First, we remove the node from the queue. Then, we call pthread_join() on the tid stored in the node. When pthread_join() returns, we have cleaned up after a thread. Only then do we free() the node, decrement the number of additional threads we need to wait for and repeat the entire process, if necessary */ curnode = (cnode *) queue_get(&cq.cleanup); pthread_mutex_unlock(&cq.control.mutex); pthread_join(curnode->tid,NULL); printf("joined with thread %dn",curnode->threadnum); free(curnode); numthreads--; } } int create_threads(void) { int x; cnode *curnode; for (x=0; xthreadnum=x; if (pthread_create(&curnode->tid, NULL, threadfunc, (void *) curnode)) return 1; printf("created thread %dn",x); numthreads++; } return 0; } void initialize_structs(void) { numthreads=0; if (control_init(&wq.control)) dabort(); queue_init(&wq.work); if (control_init(&cq.control)) { control_destroy(&wq.control); dabort(); } queue_init(&wq.work); control_activate(&wq.control); } void cleanup_structs(void) { control_destroy(&cq.control); control_destroy(&wq.control); } int main(void) { int x; wnode *mywork; initialize_structs(); /* CREATION */ if (create_threads()) { printf("Error starting threads... cleaning up.n"); join_threads(); dabort(); } pthread_mutex_lock(&wq.control.mutex); for (x=0; x<16000; x++) { mywork=malloc(sizeof(wnode)); if (!mywork) { printf("ouch! can't malloc!n"); break; } mywork->jobnum=x; queue_put(&wq.work,(node *) mywork); } pthread_mutex_unlock(&wq.control.mutex); pthread_cond_broadcast(&wq.control.cond); printf("slee...n"); sleep(2); printf("deactivating work queue...n"); control_deactivate(&wq.control); /* CLEANUP */ join_threads(); cleanup_structs(); }

接著，建立清除佇列。註釋說明了它的工作方式。好，現在讓我們跳過 threadfunc()、join_threads()、create_threads() 和 initialize_structs() 呼叫，直接跳到 main()。所做的第一件事就是初始化結構 -- 這包括初始化 data_controls 和佇列，以及啟用工作佇列。

因為當某個工作程式執行緒退出時，它會將其清除節點連線到清除佇列，然後終止。那時，主執行緒會在清除佇列中檢測到這個節點（利用條件變數），並將這個節點移出佇列。因為 TID（執行緒標識）在清除節點中，所以主執行緒可以確切知道哪個執行緒已終止了。然後，主執行緒將呼叫 pthread_join(tid)，並聯接適當的工作程式執行緒。如果沒有做記錄，那麼主執行緒就需要按任意順序聯接工作程式執行緒，可能是按它們的建立順序。由於執行緒不一定按此順序終止，那麼主執行緒可能會在已經聯接了十個執行緒時，等待聯接另一個執行緒。您能理解這種設計決策是如何使關閉程式碼加速的嗎（尤其在使用幾百個工作程式執行緒的情況下）？