線程同步與互斥之條件·變量

條件變量（condition variable）

 線程間的同步與互斥技術，主要以互斥鎖和條件變量為主，條件變量和互斥所的配合使用可以很好的處理對于條件等待的線程間的同步問題。舉個例子：消費者和生產者問題。

 消費者與生產者最基本的關系是服務與被服務的關系，但是在線程同步與互斥中強調的是兩者訪問資源的關系。首先生產與消費的關系為：同步與互斥，生產與生產的關系為：互斥，消費與消費的關系為：互斥。所以維護這三種關系的有兩類人：生產者與消費者。并且生產數據與消費數據必須有場所。

所以將其簡述為三種關系兩類人一個場所(當然這里的場所并不是只能有一個，可以是多樣的)。

介紹條件變量的幾個函數：

  1.定義一個條件變量

     pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

  2.初始化條件變量（當定義沒初始化時）

     int pthread_cond_init(pthread_cond_t *restrict cond,

              const pthread_condattr_t *restrict attr);

  3.銷毀條件變量     

      int pthread_cond_destroy(pthread_cond_t *cond)

舉一個單個消費者與單個生產者問題：

  1 #include<stdio.h>
  2 #include<pthread.h>
  3 #include<assert.h>
  4 #include<stdlib.h>
  5 pthread_cond_t cond;
  6 typedef int data_type;
  7 pthread_mutex_t lock=PTHREAD_MUTEX_INITIALIZER;
  8 void push_node(data_type data);
  9 int pop_node();
 10 void* producter(void* arg)
 11 {
 12     data_type i=0;
 13     while(1)
 14    {
 15       pthread_mutex_lock(&lock);
 16       i++;
 17       push_node(i);
 18       sleep(2);
 19       pthread_mutex_unlock(&lock);
 20       printf("product done......\n");
 21       sleep(2);
 22       pthread_cond_signal(&cond);
 23       sleep(2);
 25     }
 26 
 27 }
 28 void *consumer(void* arg)
 29 {
 30     data_type res=-1;
 31    while(1)
 32    {
 33       pthread_mutex_lock(&lock);
 34       while(-1==pop_node(&res))
 35         {
 36          pthread_cond_wait(&cond,&lock);
 37          }
 38         res=pop_node(&res);
 39         printf("consumer data: %d\n",res);
 40         sleep(2);
 41         pthread_mutex_unlock(&lock);
 44         pthread_cond_signal(&cond);
 45         sleep(2);
 46 
 47     }
 48 
 49 }
 50 
 51 typedef struct _node
 52 {
 53  data_type    _data;
 54  struct _node* _next;
 55 }node, *node_p,**node_pp;
 56 
 57 node_p head=NULL;
 58  static node_p buy_node(data_type data)
 59 {
 60    node_p tmp=malloc(sizeof(node));
 61    if(tmp==NULL)
 62      {
 63        printf("malloc failed\n");
 64 
 65       }
 66      tmp->_data=data;
 67      tmp->_next=NULL;
 68      return tmp;
 69 }
 71 void init_list(node_pp phead)
 72 {
 73      *phead=buy_node(0);
 74 }
 75 
 76 void push_node(data_type data)
 77 {
 78   
 79    if(head->_next==NULL)
 80        head->_next=buy_node(data);
 81    else{
 82      node_p tmp=buy_node(data);
 83      tmp->_next=head->_next;
 84      head->_next=tmp;
 85      }
 86 }
 87 
 88 
 89 int pop_node(data_type *data)
 90 { data_type ret=0;
 91  
 92   if(head->_next==NULL)
 93       return *data;
      else{
 95    node_p tmp=head->_next;
 96    head->_next=tmp->_next;
 97    *data=tmp->_data;
 98   free(tmp);
 99    }
100   return *data;
101 }
102 int main()
103 {
104 
105   init_list(&head);
106   pthread_cond_init(&cond,NULL);
107   pthread_mutex_init(&lock,NULL);
108   pthread_t tid1,tid2;
109   pthread_create(&tid1,NULL,producter,NULL);
110   pthread_create(&tid2,NULL,consumer,NULL);
111   pthread_join(tid1,NULL);
112   pthread_join(tid2,NULL);
113   pthread_cond_destroy(&cond);
114   pthread_mutex_destroy(&lock);
115   return 0;                                                           
       }

運行結果：

結果分析：

生產者生產出一個數據之后消費者才能消費，當鏈表里沒有數據時，消費者就等待對應的條件變量和鎖，直到他們被釋放消費者才能進去消費。

擴展：多消費者與多生產者問題

 10 pthread_mutex_t plock=PTHREAD_MUTEX_INITIALIZER;
 11 pthread_mutex_t conlock=PTHREAD_MUTEX_INITIALIZER;
 12 void push_node(data_type data);
 13 int pop_node();
 14 void* producter(void* arg)
 15 {
 16     data_type i=0;
 17     while(1)
 18    {  sem_wait(&sem_product);
 19       pthread_mutex_lock(&plock);
 20       i++;
 21       push_node(i);
 22       sleep(2);
 23       pthread_mutex_unlock(&plock);
 24       sem_post(&sem_consume);
 25       printf("product done......\n");
 26        sleep(2);
 27      pthread_cond_signal(&cond);
 28       sleep(2);
 29 
 30     }
 31 
 32 }
 33 void *consumer(void* arg)
 34 {
 35     data_type res=-1;
 36    while(1)
 37    {
 38       sem_wait(&sem_consume);
 39       pthread_mutex_lock(&conlock);
 40       while(-1==pop_node(&res))
 41         {
 42          pthread_cond_wait(&cond,&plock);
 43          }
 44         res=pop_node(&res);
 45         printf("consumer data: %d\n",res);
 46         sleep(2);
 47         pthread_mutex_unlock(&conlock);
 48 
 49         sem_post(&sem_product);
 50 
 51         pthread_cond_signal(&cond);
 52 
 53         sleep(2);
 54 
 55     }

  再來引入一概念：POSIX版本下的信號量-semaphore

  這個信號量也相當于一個計數器，記錄當前資源的數量。其進行的是PV 操作。

  有關于信號量的函數：

 sem_t sema;//定義一個信號量

 int sem_init(sem_t *sem, int pshared, unsigned int value);//初始化信號量

 int sem_destroy(sem_t *sem);//銷毀信號量

例子：

  定義一個環形buf讓生產者生產數據，消費者消費數據，生產者不能將消費者套圈，消費者也不能超過消費者。

  1 #include<stdio.h>

  2 #include<semaphore.h>

  3 #include<pthread.h>

  4 #define _SIZE_  20

  5 sem_t blank;

  6 sem_t data;

  7 int buf[_SIZE_];

  8 void *product(void*arg)

  9 {

 10    int index=0;

 11    int count=0;

 12    while(1)

 13    {

 14      sem_wait(&blank);//申請格子

 15      buf[index]=count++;

 16      sem_post(&data);//釋放數據

 17      sleep(10);

 18      index++;

 19      index%=_SIZE_;

 20    }

    }

 25 void* consume(void* arg)

 26 {

 27   int index=0;

 28   int count=0;

 29   while(1)

 30   {

 31      sem_wait(&data);//申請數據

 32      count=buf[index];

 33      printf("consume data:  %d\n",count);

 34      sem_post(&blank);//釋放格子

 35      sleep(5);

 36      index++;

 37      index%=_SIZE_;

 38   }

 41 }

 42 int main()

 43 {

 44   pthread_t tid1,tid2;

 45   pthread_create(&tid1,NULL,product,NULL);

 46   pthread_create(&tid2,NULL,consume,NULL);

 47   sem_init(&blank,0,_SIZE_);//有20個格子的數量

 48   sem_init(&data,0,0);

 49   pthread_join(tid1,NULL);

 50   pthread_join(tid2,NULL);

 51   sem_destroy(&blank);

 52   sem_destroy(&data);

 53   return 0;

 54 }

   程序分析：    這個程序就滿足上述條件，生產者不會將消費者套圈，因為信號量在記錄格子的數量，同樣的消費者也不會超過生產者，因為消費的時候數據在減少。