4、Linux多執行緒，執行緒同步（2）

weixin_34391854發表於2011-08-14

Linux執行緒

2）條件變數（cond）

利用執行緒間共享的全域性變數進行同步的一種機制。條件變數上的基本操作有：觸發條件(當條件變為 true 時)；等待條件，掛起執行緒直到其他執行緒觸發條件。

int pthread_cond_init(pthread_cond_t *cond,pthread_condattr_t *cond_attr);

int pthread_cond_wait(pthread_cond_t *cond,pthread_mutex_t *mutex);

int pthread_cond_timewait(pthread_cond_t *cond,pthread_mutex *mutex,const timespec *abstime);

int pthread_cond_destroy(pthread_cond_t *cond);

int pthread_cond_signal(pthread_cond_t *cond);

int pthread_cond_broadcast(pthread_cond_t *cond); //解除所有執行緒的阻塞

(1)初始化.init()或者pthread_cond_t cond=PTHREAD_COND_INITIALIER（前者為動態初始化，後者為靜態初始化）;屬性置為NULL

(2)等待條件成立.pthread_wait,pthread_timewait.wait()釋放鎖,並阻塞等待條件變數為真，timewait()設定等待時間,仍未signal,返回ETIMEOUT(加鎖保證只有一個執行緒wait)

(3)啟用條件變數:pthread_cond_signal,pthread_cond_broadcast(啟用所有等待執行緒)

(4)清除條件變數:destroy;無執行緒等待,否則返回EBUSY

對於

int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);

int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime);

一定要在mutex的鎖定區域內使用。

如果要正確的使用pthread_mutex_lock與pthread_mutex_unlock，請參考

pthread_cleanup_push和pthread_cleanup_pop巨集，它能夠線上程被cancel的時候正確的釋放mutex！

另外，posix1標準說，pthread_cond_signal與pthread_cond_broadcast無需考慮呼叫執行緒是否是mutex的擁有者，也就是說，可以在lock與unlock以外的區域呼叫。如果我們對呼叫行為不關心，那麼請在lock區域之外呼叫吧。

說明：

(1)pthread_cond_wait 自動解鎖互斥量(如同執行了pthread_unlock_mutex)，並等待條件變數觸發。這時執行緒掛起，不佔用CPU時間，直到條件變數被觸發（變數為ture）。在呼叫 pthread_cond_wait之前，應用程式必須加鎖互斥量。pthread_cond_wait函式返回前，自動重新對互斥量加鎖(如同執行了pthread_lock_mutex)。

(2)互斥量的解鎖和在條件變數上掛起都是自動進行的。因此，在條件變數被觸發前，如果所有的執行緒都要對互斥量加鎖，這種機制可保證線上程加鎖互斥量和進入等待條件變數期間，條件變數不被觸發。條件變數要和互斥量相聯結，以避免出現條件競爭——個執行緒預備等待一個條件變數，當它在真正進入等待之前，另一個執行緒恰好觸發了該條件（條件滿足訊號有可能在測試條件和呼叫pthread_cond_wait函式（block）之間被髮出，從而造成無限制的等待）。

(3)pthread_cond_timedwait 和 pthread_cond_wait 一樣，自動解鎖互斥量及等待條件變數，但它還限定了等待時間。如果在abstime指定的時間內cond未觸發，互斥量mutex被重新加鎖，且pthread_cond_timedwait返回錯誤 ETIMEDOUT。abstime 引數指定一個絕對時間，時間原點與 time 和 gettimeofday 相同：abstime = 0 表示 1970年1月1日00:00:00 GMT。

(4)pthread_cond_destroy 銷燬一個條件變數，釋放它擁有的資源。進入 pthread_cond_destroy 之前，必須沒有在該條件變數上等待的執行緒。

(5)條件變數函式不是非同步訊號安全的，不應當在訊號處理程式中進行呼叫。特別要注意，如果在訊號處理程式中呼叫 pthread_cond_signal 或 pthread_cond_boardcast 函式，可能導致呼叫執行緒死鎖。

示例程式1

View Code

#include <stdio.h>
#include <pthread.h>
#include "stdlib.h"
#include "unistd.h"

pthread_mutex_t mutex;
pthread_cond_t cond;

void hander(void *arg)
{
    free(arg);
    (void)pthread_mutex_unlock(&mutex);
}

void *thread1(void *arg)
{
     pthread_cleanup_push(hander, &mutex);
while(1)
     {
         printf("thread1 is running\n");
         pthread_mutex_lock(&mutex);
         pthread_cond_wait(&cond,&mutex);
         printf("thread1 applied the condition\n");
         pthread_mutex_unlock(&mutex);
         sleep(4);
     }
     pthread_cleanup_pop(0);
 }

void *thread2(void *arg)
{
while(1)
     {
         printf("thread2 is running\n");
         pthread_mutex_lock(&mutex);
         pthread_cond_wait(&cond,&mutex);
         printf("thread2 applied the condition\n");
         pthread_mutex_unlock(&mutex);
         sleep(1);
     }
}
int main()
{
     pthread_t thid1,thid2;
     printf("condition variable study!\n");
     pthread_mutex_init(&mutex,NULL);
     pthread_cond_init(&cond,NULL);
     pthread_create(&thid1,NULL,thread1,NULL);
     pthread_create(&thid2,NULL,thread2,NULL);
     sleep(1);
do
     {
         pthread_cond_signal(&cond);
     }while(1);
     sleep(20);
     pthread_exit(0);
return 0;
}

示例程式2

View Code

#include <pthread.h> 
#include <unistd.h> 
#include "stdio.h"
#include "stdlib.h"


static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER; 
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER; 

struct node 
{ 
int n_number; 
struct node *n_next; 
} *head = NULL; 

/*[thread_func]*/ 
static void cleanup_handler(void *arg) 
{ 
    printf("Cleanup handler of second thread./n"); 
    free(arg); 
    (void)pthread_mutex_unlock(&mtx); 
} 

static void *thread_func(void *arg) 
{ 
struct node *p = NULL; 

    pthread_cleanup_push(cleanup_handler, p); 
while (1) 
    { 
//這個mutex主要是用來保證pthread_cond_wait的併發性
        pthread_mutex_lock(&mtx);          
while (head == NULL)   
        {               
//這個while要特別說明一下，單個pthread_cond_wait功能很完善，為何
//這裡要有一個while (head == NULL)呢？因為pthread_cond_wait裡的線
//程可能會被意外喚醒，如果這個時候head != NULL，則不是我們想要的情況。
//這個時候，應該讓執行緒繼續進入pthread_cond_wait

// pthread_cond_wait會先解除之前的pthread_mutex_lock鎖定的mtx，
//然後阻塞在等待對列裡休眠，直到再次被喚醒（大多數情況下是等待的條件成立
//而被喚醒，喚醒後，該程式會先鎖定先pthread_mutex_lock(&mtx);，再讀取資源
//用這個流程是比較清楚的/*block-->unlock-->wait() return-->lock*/
            pthread_cond_wait(&cond, &mtx);         
            p = head; 
            head = head->n_next; 
            printf("Got %d from front of queue/n", p->n_number); 
            free(p); 
        }
        pthread_mutex_unlock(&mtx);             //臨界區資料操作完畢，釋放互斥鎖
    } 
    pthread_cleanup_pop(0); 
return 0; 
} 

int main(void) 
{ 
    pthread_t tid; 
int i; 
struct node *p; 
//子執行緒會一直等待資源，類似生產者和消費者，但是這裡的消費者可以是多個消費者，而
//不僅僅支援普通的單個消費者，這個模型雖然簡單，但是很強大
    pthread_create(&tid, NULL, thread_func, NULL);   
    sleep(1);
for (i = 0; i < 10; i++) 
    { 
        p = (struct node*)malloc(sizeof(struct node)); 
        p->n_number = i; 
        pthread_mutex_lock(&mtx);             //需要操作head這個臨界資源，先加鎖，
        p->n_next = head; 
        head = p; 
        pthread_cond_signal(&cond); 
        pthread_mutex_unlock(&mtx);           //解鎖
        sleep(1); 
    } 
    printf("thread 1 wanna end the line.So cancel thread 2./n"); 

//關於pthread_cancel，有一點額外的說明，它是從外部終止子執行緒，子執行緒會在最近的取消點，退出
//執行緒，而在我們的程式碼裡，最近的取消點肯定就是pthread_cond_wait()了。
    pthread_cancel(tid);            
    pthread_join(tid, NULL); 
    printf("All done -- exiting/n"); 
return 0; 
}