Linux多執行緒程式設計詳細解析----條件變數 pthread_cond_t

阿新 • • 發佈：2019-02-18

Linux作業系統下的多執行緒程式設計詳細解析----條件變數

1.初始化條件變數pthread_cond_init

#include <pthread.h>

int pthread_cond_init(pthread_cond_t *cv,

const pthread_condattr_t *cattr);

返回值：函式成功返回0；任何其他返回值都表示錯誤

初始化一個條件變數。當引數cattr為空指標時，函式建立的是一個預設的條件變數。否則條件變數的屬性將由cattr中的屬性值來決定。呼叫 pthread_cond_init函式時，引數cattr為空指標等價於cattr中的屬性為預設屬性，只是前者不需要cattr所佔用的記憶體開銷。這個函式返回時，條件變數被存放在引數cv指向的記憶體中。

可以用巨集PTHREAD_COND_INITIALIZER來初始化靜態定義的條件變數，使其具有預設屬性。這和用pthread_cond_init函式動態分配的效果是一樣的。初始化時不進行錯誤檢查。如：

pthread_cond_t cv = PTHREAD_COND_INITIALIZER;

不能由多個執行緒同時初始化一個條件變數。當需要重新初始化或釋放一個條件變數時，應用程式必須保證這個條件變數未被使用。

2.阻塞在條件變數上pthread_cond_wait

#include <pthread.h>

int pthread_cond_wait(pthread_cond_t *cv,

pthread_mutex_t *mutex);

返回值：函式成功返回0；任何其他返回值都表示錯誤

函式將解鎖mutex引數指向的互斥鎖，並使當前執行緒阻塞在cv引數指向的條件變數上。

被阻塞的執行緒可以被pthread_cond_signal函式，pthread_cond_broadcast函式喚醒，也可能在被訊號中斷後被喚醒。

pthread_cond_wait函式的返回並不意味著條件的值一定發生了變化，必須重新檢查條件的值。

pthread_cond_wait函式返回時，相應的互斥鎖將被當前執行緒鎖定，即使是函數出錯返回。

一般一個條件表示式都是在一個互斥鎖的保護下被檢查。當條件表示式未被滿足時，執行緒將仍然阻塞在這個條件變數上。當另一個執行緒改變了條件的值並向條件變數發出訊號時，等待在這個條件變數上的一個執行緒或所有執行緒被喚醒，接著都試圖再次佔有相應的互斥鎖。

阻塞在條件變數上的執行緒被喚醒以後，直到pthread_cond_wait()函式返回之前條件的值都有可能發生變化。所以函式返回以後，在鎖定相應的互斥鎖之前，必須重新測試條件值。最好的測試方法是迴圈呼叫pthread_cond_wait函式，並把滿足條件的表示式置為迴圈的終止條件。如：

pthread_mutex_lock();

while (condition_is_false)

pthread_cond_wait();

pthread_mutex_unlock();

阻塞在同一個條件變數上的不同執行緒被釋放的次序是不一定的。

注意：pthread_cond_wait()函式是退出點，如果在呼叫這個函式時，已有一個掛起的退出請求，且執行緒允許退出，這個執行緒將被終止並開始執行善後處理函式，而這時和條件變數相關的互斥鎖仍將處在鎖定狀態。

3.解除在條件變數上的阻塞pthread_cond_signal

#include <pthread.h>

int pthread_cond_signal(pthread_cond_t *cv);

返回值：函式成功返回0；任何其他返回值都表示錯誤

函式被用來釋放被阻塞在指定條件變數上的一個執行緒。

必須在互斥鎖的保護下使用相應的條件變數。否則對條件變數的解鎖有可能發生在鎖定條件變數之前，從而造成死鎖。

喚醒阻塞在條件變數上的所有執行緒的順序由排程策略決定，如果執行緒的排程策略是SCHED_OTHER型別的，系統將根據執行緒的優先順序喚醒執行緒。

如果沒有執行緒被阻塞在條件變數上，那麼呼叫pthread_cond_signal()將沒有作用。

4.阻塞直到指定時間pthread_cond_timedwait

#include <pthread.h>

#include <time.h>

int pthread_cond_timedwait(pthread_cond_t *cv,

pthread_mutex_t *mp, const structtimespec * abstime);

返回值：函式成功返回0；任何其他返回值都表示錯誤

函式到了一定的時間，即使條件未發生也會解除阻塞。這個時間由引數abstime指定。函式返回時，相應的互斥鎖往往是鎖定的，即使是函數出錯返回。

注意：pthread_cond_timedwait函式也是退出點。

超時時間引數是指一天中的某個時刻。使用舉例：

pthread_timestruc_t to;

to.tv_sec = time(NULL) + TIMEOUT;

to.tv_nsec = 0;

超時返回的錯誤碼是ETIMEDOUT。

5.釋放阻塞的所有執行緒pthread_cond_broadcast

#include <pthread.h>

int pthread_cond_broadcast(pthread_cond_t *cv);

返回值：函式成功返回0；任何其他返回值都表示錯誤

函式喚醒所有被pthread_cond_wait函式阻塞在某個條件變數上的執行緒，引數cv被用來指定這個條件變數。當沒有執行緒阻塞在這個條件變數上時，pthread_cond_broadcast函式無效。

由於pthread_cond_broadcast函式喚醒所有阻塞在某個條件變數上的執行緒，這些執行緒被喚醒後將再次競爭相應的互斥鎖，所以必須小心使用pthread_cond_broadcast函式。

6.釋放條件變數pthread_cond_destroy

#include <pthread.h>

int pthread_cond_destroy(pthread_cond_t *cv);

返回值：函式成功返回0；任何其他返回值都表示錯誤

釋放條件變數。

注意：條件變數佔用的空間並未被釋放。

7.喚醒丟失問題

線上程未獲得相應的互斥鎖時呼叫pthread_cond_signal或pthread_cond_broadcast函式可能會引起喚醒丟失問題。

喚醒丟失往往會在下面的情況下發生：

一個執行緒呼叫pthread_cond_signal或pthread_cond_broadcast函式；
另一個執行緒正處在測試條件變數和呼叫pthread_cond_wait函式之間；
沒有執行緒正在處在阻塞等待的狀態下。

===============================================================================

條件鎖pthread_cond_t

說明，
等待執行緒
1。使用pthread_cond_wait前要先加鎖
2。pthread_cond_wait內部會解鎖，然後等待條件變數被其它執行緒啟用
3。pthread_cond_wait被啟用後會再自動加鎖

啟用執行緒：
1。加鎖（和等待執行緒用同一個鎖）
2。pthread_cond_signal傳送訊號
3。解鎖
啟用執行緒的上面三個操作在執行時間上都在等待執行緒的pthread_cond_wait函式內部。

程式示例：
#include <stdio.h> #include <pthread.h> #include <unistd.h> pthread_mutex_t count_lock; pthread_cond_t count_nonzero; unsigned count = 0; void *decrement_count(void *arg) { pthread_mutex_lock(&count_lock); printf("decrement_count get count_lock/n"); while(count == 0) { printf("decrement_count count == 0 /n"); printf("decrement_count before cond_wait /n"); pthread_cond_wait(&count_nonzero, &count_lock); printf("decrement_count after cond_wait /n"); } count = count + 1; pthread_mutex_unlock(&count_lock); } void *increment_count(void *arg) { pthread_mutex_lock(&count_lock); printf("increment_count get count_lock /n"); if(count == 0) { printf("increment_count before cond_signal /n"); pthread_cond_signal(&count_nonzero); printf("increment_count after cond_signal /n"); } count = count + 1; pthread_mutex_unlock(&count_lock); } int main(void) { pthread_t tid1, tid2; pthread_mutex_init(&count_lock, NULL); pthread_cond_init(&count_nonzero, NULL); pthread_create(&tid1, NULL, decrement_count, NULL); sleep(2); pthread_create(&tid2, NULL, increment_count, NULL); sleep(10); pthread_exit(0); return 0; }

執行結果：

[[email protected] pthread]$ gcc -o pthread_cond pthread_cond.c -lpthread
[[email protected] pthread]$ ./pthread_cond
decrement_count get count_lock
decrement_count count == 0
decrement_count before cond_wait
increment_count get count_lock
increment_count before cond_signal
increment_count after cond_signal
decrement_count after cond_wait

===============================================================================

多執行緒程式設計,條件變數pthread_cond_t應用

程式程式碼：

#include <stdio.h> #include <pthread.h> #include <unistd.h> pthread_mutex_t counter_lock; pthread_cond_t counter_nonzero; int counter = 0; int estatus = -1; void *decrement_counter(void *argv); void *increment_counter(void *argv); int main(int argc, char **argv) { printf("counter: %d/n", counter); pthread_t thd1, thd2; int ret; ret = pthread_create(&thd1, NULL, decrement_counter, NULL); if(ret){ perror("del:/n"); return 1; } ret = pthread_create(&thd2, NULL, increment_counter, NULL); if(ret){ perror("inc: /n"); return 1; } int counter = 0; while(counter != 10){ printf("counter: %d/n", counter); sleep(1); counter++; } return 0; } void *decrement_counter(void *argv) { pthread_mutex_lock(&counter_lock); while(counter == 0) pthread_cond_wait(&counter_nonzero, &counter_lock); counter--; pthread_mutex_unlock(&counter_lock); return &estatus; } void *increment_counter(void *argv) { pthread_mutex_lock(&counter_lock); if(counter == 0) pthread_cond_signal(&counter_nonzero); counter++; pthread_mutex_unlock(&counter_lock); return &estatus; }

執行結果：
[[email protected] pthread]$ gcc -o pthread_cond2 pthread_cond2.c -lpthread
[[email protected] pthread]$ ./pthread_cond2
counter: 0
counter: 0
counter: 1
counter: 2
counter: 3
counter: 4
counter: 5
counter: 6
counter: 7
counter: 8
counter: 9

除錯程式的執行過程：

1、開始時 counter 為0 （main） 2、ret = pthread_create(&thrd1, NULL, decrement_counter, NULL)處生成一個thrd1執行緒執行decrement_counter(), 此執行緒內函式執行流程為: 先鎖定 互斥鎖（count_lock）如果counter為0,此執行緒被阻塞在條件變數（count_nonzero）上.同時釋放互斥鎖count_lock（wait內部會先釋放鎖，等待signal啟用後自動再加上鎖）. 3、與此同時主程式還在執行,建立另一個執行緒thrd2執行 increment_counter, 此執行緒內的函式流程如下: 先鎖定 互斥鎖（count_lock）【wait內部釋放鎖的互斥鎖】如果counter為0, 喚醒在條件變數（count_nonzero）上的執行緒即thrd1.但是由於有互斥鎖count_lock【signal啟用後，wait內部又自動加上鎖了】, thrd1還是在等待. 然後count++,釋放互斥鎖,.......thrd1由於互斥鎖釋放,重新判斷counter是不是為0,如果為0再把執行緒阻塞在條件變數count_nonzero上,但這時counter已經為1了.所以執行緒繼續執行.counter--釋放互斥鎖......（退出後，執行主執行緒main） 4、與此主程式間隔列印counter執行一段時間退出.

注：更清晰的執行流程請詳見如下“改進程式碼”

後記,在編譯的時候加上 -lpthread 改進程式碼：

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

pthread_mutex_t counter_lock;
pthread_cond_t counter_nonzero;
int counter = 0;
int estatus = -1;

void *decrement_counter(void *argv);
void *increment_counter(void *argv);

int main(int argc, char **argv)
{
    printf("counter: %d/n", counter);
    pthread_t thd1, thd2;
    int ret;

ret = pthread_create(&thd1, NULL, decrement_counter, NULL);
    if(ret){
        perror("del:/n");
        return 1;
    }

ret = pthread_create(&thd2, NULL, increment_counter, NULL);
    if(ret){
        perror("inc: /n");
        return 1;
    }

int counter = 0;
    while(counter != 10){
        printf("counter(main): %d/n", counter);
        sleep(1);
        counter++;
    }

return 0;
}

void *decrement_counter(void *argv)
{
    printf("counter(decrement): %d/n", counter);
    pthread_mutex_lock(&counter_lock);
    while(counter == 0)
        pthread_cond_wait(&counter_nonzero, &counter_lock); //進入阻塞(wait)，等待啟用(signal)
    
    printf("counter--(before): %d/n", counter);    
    counter--; //等待signal啟用後再執行
    printf("counter--(after): %d/n", counter);    
    pthread_mutex_unlock(&counter_lock);

return &estatus;
}

void *increment_counter(void *argv)
{
    printf("counter(increment): %d/n", counter);
    pthread_mutex_lock(&counter_lock);
    if(counter == 0)
        pthread_cond_signal(&counter_nonzero); //啟用(signal)阻塞(wait)的執行緒(先執行完signal執行緒，然後再執行wait執行緒)

printf("counter++(before): %d/n", counter);    
    counter++; 
    printf("counter++(after): %d/n", counter);    
    pthread_mutex_unlock(&counter_lock);

return &estatus;
}

執行結果： [[email protected] pthread]$ gcc -o pthread_cond2 pthread_cond2.c -lpthread
[[email protected] pthread]$ ./pthread_cond2
counter: 0
counter(main): 0
counter(decrement): 0
counter(increment): 0
counter++(before): 0
counter++(after): 1
counter--(before): 1
counter--(after): 0
counter(main): 1
counter(main): 2
counter(main): 3
counter(main): 4
counter(main): 5
counter(main): 6
counter(main): 7
counter(main): 8
counter(main): 9

Linux多執行緒程式設計詳細解析----條件變數 pthread_cond_t

Linux多執行緒程式設計詳細解析----條件變數 pthread_cond_t

Linux作業系統下的多執行緒程式設計詳細解析----條件變數pthread_cond_t

Java多執行緒程式設計詳細解析

Linux多執行緒程式設計例項解析

Linux多執行緒實踐(8) --Posix條件變數解決生產者消費者問題

Linux多執行緒程式設計---執行緒間同步（互斥鎖、條件變數、訊號量和讀寫鎖）

java多執行緒程式設計詳細入門教程

linux多執行緒程式設計，用 pthread_cond_timedwait 代替sleep

Linux多執行緒程式設計

Linux多執行緒程式設計入門

Linux多執行緒程式設計小結

Linux 多執行緒程式設計（一）

Linux多執行緒程式設計之員工資訊管理系統

linux多執行緒程式設計，你還在用sleep麼？用pthread_cond_timedwait吧

Linux多執行緒同步機制 .linux多執行緒程式設計機制

（Linux多執行緒程式設計（不限Linux））多執行緒操作

Linux多執行緒程式設計講解之系列六

Linux多執行緒程式設計講解之系列五

linux多執行緒程式設計(C)：訊號量實現的執行緒安全佇列

Linux多執行緒程式設計———重點區分

Linux多執行緒程式設計詳細解析----條件變數 pthread_cond_t

相關推薦