2. 程式人生 > >linux同步機制條件變數

linux同步機制條件變數

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

目錄

 

1、條件變數

2、條件變數API

2.1 pthread_cond_init

2.2 pthread_cond_wait

2.3 pthread_cond_timedwait

2.4 pthread_cond_signal

2.5 pthread_cond_broadcast

2.6 pthread_cond_destroy

3、喚醒丟失問題

4、生產者、消費者例子

1、條件變數

linux多執行緒的環境中使用互斥鎖mutex來保護變數的同步，但互斥鎖只有兩種狀態鎖定、非鎖定，如果某個變數的條件沒有滿足就對變數進行加鎖處理就會白白的損耗CPU，這時可以使用條件變數pthread_cond_t，條件變數pthread_cond_t一般是和互斥鎖配合使用，當條件不滿足條件變數就會掛起並釋放互斥鎖，這時就不會損耗CPU，直到條件滿足條件變數就會重新加互斥鎖保護。

2、條件變數API

2.1 pthread_cond_init

條件變數的初始化有動態初始化、靜態初始化兩種方式，呼叫pthread_cond_init就是動態初始化條件變數，catter是條件變數的屬性，如果是預設屬性就是NULL，我們一般是設定為預設屬性。

#include <pthread.h>
int pthread_cond_init(pthread_cond_t *cv,
                      const pthread_condattr_t *cattr);
返回值：函式成功返回0；任何其他返回值都表示錯誤

靜態初始化是呼叫巨集PTHREAD_COND_INITIALIZER，預設是預設模式。

pthread_cond_t cv = PTHREAD_COND_INITIALIZER;

2.2 pthread_cond_wait

pthread_cond_wait函式會釋放互斥鎖mutex，然後執行緒阻塞掛起，直到被pthread_cond_singal函式、pthread_cond_broadcast喚醒，或者被訊號中斷後喚醒。

pthread_cond_wait呼叫格式如下：

pthread_mutex_lock();
while(condition_is_false)
    pthread_cond_wait();
pthread_mutex_unlock;

這裡用while而不是用if判斷條件是否滿足，因為條件阻塞時可能被一個訊號中斷喚醒，但這時條件還沒有準備好，所以要再次呼叫pthread_cond_wait()掛起執行緒。

呼叫pthread_cond_wait處理過程：

釋放互斥鎖 --> 程序阻塞掛起

pthread_cond_wait收到喚醒訊號處理過程：

收到喚醒訊號-->對互斥鎖加鎖

pthread_cond_wait函式：

#include <pthread.h>
int pthread_cond_wait(pthread_cond_t *cv, pthread_mutex_t *mutex);
返回值：函式成功返回0；任何其他返回值都表示錯誤

2.3 pthread_cond_timedwait

pthread_cond_timedwait在pthread_cond_wait的基礎上新增一個超時時間，如果超時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_timestruc_t to;
to.tv_sec = time(NULL) + TIMEOUT;   //秒
to.tv_nsec = 0;                    //毫秒

2.4 pthread_cond_signal

pthread_cond_signal用來釋放阻塞在條件變數上的執行緒，如果有對個執行緒被條件變數阻塞，pthread_cond_signal只釋放一個執行緒，至於釋放那個由系統排程策略決定。條件變數必須在互斥鎖 的保護下使用，否則釋放條件變數可能在鎖定條件變數之前呼叫那麼就會進入死鎖狀態。

pthread_cond_signal：

#include <pthread.h>
int pthread_cond_signal(pthread_cond_t *cv);
返回值：函式成功返回0；任何其他返回值都表示錯誤

2.5 pthread_cond_broadcast

pthread_cond_broadcast會喚醒所有阻塞條件變數cv上的執行緒。當所有執行緒被喚醒就會進入加互斥鎖的競爭中。

#include <pthread.h>
int pthread_cond_broadcast(pthread_cond_t *cv);
返回值：函式成功返回0；任何其他返回值都表示錯誤

2.6 pthread_cond_destroy

pthread_cond_destroy會銷燬條件變數cv，釋放條件變數使用的空間。

#include <pthread.h>
int pthread_cond_destroy(pthread_cond_t *cv);
返回值：函式成功返回0；任何其他返回值都表示錯誤

3、喚醒丟失問題

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

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

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

 

4、生產者、消費者例子

（1）不使用條件變數

不使用條件變數：

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

pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

typedef struct node{
	int data;
	struct node * next;
	
}*node_p;
node_p head = NULL;

node_p init_node(int data){
	
	node_p tmp;	
	tmp = (node_p) malloc(sizeof(struct node));
	if(tmp == NULL){
		printf("memeroy out!\n");
		return NULL;
	}
	
	tmp->data = data;
	return tmp;
}

void push_node(node_p head, int data){
	
	node_p tmp = init_node(data);
	if(tmp == NULL){
		printf("push_node err!\n");
		return;
	}
	
	tmp->next = head->next;
	head->next = tmp;
}

int pop_node(node_p head){
	int ret = -1;
	
	if(head->next){
		node_p tmp;
		tmp = head->next;
		head->next = tmp->next;
		ret = tmp->data;
		free(tmp);
	}
	
	return ret;
}

void show_node(node_p head){
	node_p tmp;
	tmp = head->next;
	
	while(tmp){
		printf("data:%d\n", tmp->data);
		tmp = tmp->next;
	}
}
void *consumer(void *argv){
	
	while(1){
		sleep(1);
		pthread_mutex_lock(&lock);
		if(head->next == NULL){
			printf("producter not read...\n");
		}else{
			printf("consumer:%d\n", pop_node(head));
		}
		pthread_mutex_unlock(&lock);
	}
}

void *producter(void *argv){
	int data;
	while(1){
		sleep(5);
		pthread_mutex_lock(&lock);
		data = rand()%2019;
		push_node(head, data);
		printf("producter:%d\n", data);
		pthread_mutex_unlock(&lock);
	}
}

int main(){
	pthread_t t1, t2;
	
	head = init_node(0);	
	if(head == NULL){
		printf("init head fail...\n");
		return -1;
	}
	
	pthread_create(&t1, NULL, consumer, NULL);
	pthread_create(&t2, NULL, producter, NULL);
	
	pthread_join(t1, NULL);
	pthread_join(t2, NULL);
}

執行結構如下：

[email protected]:/home/c_test/cond# gcc producter_consumer.c -lpthread
[email protected]:/home/c_test/cond# ./a.out
producter not read...
producter not read...
producter not read...
producter not read...
producter:1957
consumer:1957
producter not read...
producter not read...
producter not read...
producter not read...
producter:766
consumer:766
producter not read...
producter not read...
producter not read...
producter not read...
producter:1050
consumer:1050

我們可以看到當生產者沒有準備好時，消費者就會一致佔用CPU，這樣是在浪費CPU時間。

（2）加條件變數

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

pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

typedef struct node{
	int data;
	struct node * next;
	
}*node_p;
node_p head = NULL;

node_p init_node(int data){
	
	node_p tmp;	
	tmp = (node_p) malloc(sizeof(struct node));
	if(tmp == NULL){
		printf("memeroy out!\n");
		return NULL;
	}
	
	tmp->data = data;
	return tmp;
}

void push_node(node_p head, int data){
	
	node_p tmp = init_node(data);
	if(tmp == NULL){
		printf("push_node err!\n");
		return;
	}
	
	tmp->next = head->next;
	head->next = tmp;
}

int pop_node(node_p head){
	int ret = -1;
	
	if(head->next){
		node_p tmp;
		tmp = head->next;
		head->next = tmp->next;
		ret = tmp->data;
		free(tmp);
	}
	
	return ret;
}

void show_node(node_p head){
	node_p tmp;
	tmp = head->next;
	
	while(tmp){
		printf("data:%d\n", tmp->data);
		tmp = tmp->next;
	}
}
void *consumer(void *argv){
	
	while(1){
		sleep(1);
		pthread_mutex_lock(&lock);
		while(head->next == NULL){
			printf("producter not read...\n");
			pthread_cond_wait(&cond, &lock);
			break;
		}
		
		printf("consumer:%d\n", pop_node(head));
		pthread_mutex_unlock(&lock);
	}
}

void *producter(void *argv){
	int data;
	while(1){
		sleep(5);
		pthread_mutex_lock(&lock);
		
		data = rand()%2019;
		push_node(head, data);	
		printf("producter:%d\n", data);	
		
		pthread_cond_signal(&cond);
		pthread_mutex_unlock(&lock);
		
	}
}

int main(){
	pthread_t t1, t2;
	
	head = init_node(0);	
	if(head == NULL){
		printf("init head fail...\n");
		return -1;
	}
	
	pthread_create(&t1, NULL, consumer, NULL);
	pthread_create(&t2, NULL, producter, NULL);
	
	pthread_join(t1, NULL);
	pthread_join(t2, NULL);
	pthread_cond_destroy(&cond);
}

執行結果：

[email protected]:/home/c_test/cond# gcc producter_consumer_cond.c -lpthread
[email protected]:/home/c_test/cond# ./a.out
producter not read...
producter:1957
consumer:1957
producter not read...
producter:766
consumer:766
producter not read...
producter:1050
consumer:1050
producter not read...
producter:1165
consumer:1165

加了條件變數後當條件沒有準備好時wait_cond_wait就會釋放互斥鎖消費者執行緒掛起，消費者讓出CPU給生產者而不會白白佔用CPU。

相關推薦

linux同步機制條件變數

目錄   1、條件變數 2、條件變數API 2.1 pthread_cond_init 2.2 pthread_cond_wait 2.3 pthread_cond_timedwait 2.4 pthread_cond_signal

執行緒同步機制條件變數的使用與思考

條件變數是Linux執行緒同步的一種機制，與互斥量一起使用時，允許執行緒以無競爭的方式等待特定條件的發生 關鍵函式 初始化與登出 #include <pthread.h> // 靜態初始化 pthread_cond_

Linux 同步機制：條件變數

條件變數的優勢 條件變數提供了一種執行緒間的通知機制，達到條件喚醒對應執行緒，配合互斥量，可以解決多執行緒中大多數的同步問題。需要訊號量的解決問題的基本都可以用條件變數加互斥量解決。由於訊號量使用起來容易出錯，實際工程中用互斥量和條件變數的更多。 互斥量可以

Linux執行緒同步之條件變數pthread_cond_t

Linux執行緒同步之條件變數pthread_cond_t  一直以來都天真的認為執行緒間同步的方法只有訊號量，互斥量，郵箱，訊息佇列，知道最近開始研究一些Linux方面的程式碼才發現自己是多麼的很傻很天真。在Linux中還存在這一種叫做條件變數的東西。必須承認我在理解這個概念上花了很

Linux 多執行緒同步問題 條件變數

互斥鎖：用來上鎖。 條件變數：用來等待，當條件變數用來自動阻塞一個執行緒，直到某特殊情況發生為止。通常條件變數和互斥鎖同時使用。 函式介紹： 1． 名稱： pthread_cond_init 目標： 條件變數初始化 標頭檔案： #include &

四十一、Linux 執行緒——執行緒同步之條件變數

41.1 概念 41.1.1 條件變數的介紹 互斥鎖的缺點是它只有兩種狀態：鎖定和非鎖定 條件變數通過允許執行緒阻塞和等待另一個執行緒傳送訊號的方法彌補了互斥鎖的不足 條件變數內部是一個等待佇列，放置等待的執行緒，執行緒在條件變數上等待和通知，互斥鎖用來保護等待佇列（對等待佇列上鎖），條件變

四十二、Linux 執行緒——執行緒同步之條件變數之執行緒狀態轉換

42.1 執行緒狀態轉換 42.1.1 狀態轉換圖 　　 42.1.2 一個執行緒計算，多個執行緒獲取的案例 1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <pthread.h> 4

18.執行緒同步：條件變數cond

1.條件變數 1.條件變數(Condtion Variable)是在多執行緒程式中用來實現“等待->喚醒”邏輯常用的方法。 2.條件變數+互斥鎖（一起使用） 執行緒同步——互斥鎖 阻塞執行緒——條件變數 2.條件變數使用場景舉例 舉個簡單的例子，應用程式A中包含兩

18.執行緒同步：條件變數cond—>生產者消費者模型

條件變數：[單生產者/單消費者]單鏈表的插入和刪除 typedef struct node{//宣告連結串列型別 int data;

執行緒同步（條件變數）

參考：https://blog.csdn.net/qq_37653144/article/details/81988615 https://blog.csdn.net/qq_34328833/article/details/56012780  https://blog.csdn.n

linux同步機制之互斥鎖

 版權宣告：如有需要，可供轉載，但請註明出處：https://blog.csdn.net/City_of_skey/article/details/85494572   目錄 1、簡介 2、API 2.1 pthread_mutex_init 2.2 pt

linux作業系統之條件變數

（1）條件變數                條件變數本身不是鎖，但它可以造成執行緒阻塞，通常與互斥鎖配合使用。 （2）條件鎖相關函式               pthread_cond_t型別，用於定義條件變數          1）初始化一個條件變數：pthre

linux同步機制之訊號量down 和up

訊號量（semaphore） 　　Linux核心的訊號量在概念和原理上和使用者態的System V的IPC機制訊號量是相同的，不過他絕不可能在核心之外使用，因此他和System V的IPC機制訊號量毫不相干。 　　訊號量在建立時需要設定一個初始值，表示同時能有幾個任務能訪問

執行緒同步之條件變數

程序空間中有一個儲存量A，該程序空間記憶體在多個執行緒，這多個執行緒都會訪問到A，或讀或寫，為了保障每個執行緒當前讀到的是正確的A而不是別的執行緒正在修改過程中的A，我們在訪問A之前需要對A進行加鎖，使得我們在訪問A的時候別的執行緒禁止訪問A，這是互斥量鎖。或者允許多個執行

Linux系統程式設計—條件變數

條件變數是用來等待執行緒而不是上鎖的，條件變數通常和互斥鎖一起使用。條件變數之所以要和互斥鎖一起使用，主要是因為互斥鎖的一個明顯的特點就是它只有兩種狀態：鎖定和非鎖定，而條件變數可以通過允許執行緒阻塞和等待另一個執行緒傳送訊號來彌補互斥鎖的不足，所以互斥鎖和條件變數通常一起使用。 當條件滿足的時候，執行緒通

linux下多執行緒同步機制之訊號量、互斥量、讀寫鎖、條件變數

之前有寫過類似的部落格，這東西不用老忘，現在又有更清晰的理解了。 一、訊號量 編譯時候加入-lrt 訊號量最基本的兩個操作就是PV操作：P()操作實現訊號量減少，V()操作實現訊號量的增加 訊號量的值取決於訊號量的型別，訊號量的型別有多種： （1）二進位制訊號量：0與1.

Linux 多線程同步機制:互斥量、信號量、條件變量

linux 信號量 條件變量 互斥量：互斥量提供對共享資源的保護訪問，它的兩種狀態：lock和unlock,用來保證某段時間內只有一個線程使用共享資源，互斥量的數據類型是pthread_mutex_t主要涉及函數：pthread_mutex_lock() pthread_mutex_tryloc

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

本篇博文轉自http://zhangxiaoya.github.io/2015/05/15/multi-thread-of-c-program-language-on-linux/ Linux下提供了多種方式來處理執行緒同步，最常用的是互斥鎖、條件變數、訊號量和讀寫鎖。  下面是思維導

Linux 執行緒同步---條件變數

        pthread_cond_signal 使在條件變數上等待的執行緒中的一個執行緒重新開始。如果沒有等待的執行緒，則什麼也不做。如果有多個執行緒在等待該條件，只有一個能重啟動，但不能指定哪一個。    

Linux 學習筆記—執行緒同步之互斥量與條件變數

執行緒同步（同步的意思是協同步調） 執行緒同步機制包括互斥，讀寫鎖以及條件變數等 3.2.1 互斥量(互斥鎖) **互斥量本質是一把鎖，在訪問公共資源前對互斥量設定（加鎖），確保同一時間只有一個執行緒訪問資料，在訪問完成後再釋放（解鎖）互斥量。**在互斥量加鎖之