POSIX多线程编程-条件变量pthread_cond_t

条件变量通过允许线程阻塞和等待另一个线程发送信号的方法弥补了互斥锁的不足，它常和互斥锁一起使用。使用时，条件变量被用来阻塞一个线程，当条件不满足时，线程往往解开相应的互斥锁并等待条件发生变化。一旦其它的某个线程改变了条件变量，它将通知相应的条件变量唤醒一个或多个正被此条件变量阻塞的线程。这些线程将重新锁定互斥锁并重新测试条件是否满足。一般说来，条件变量被用来进行线承间的同步。

 

1.条件变量的结构为pthread_cond_t (相当于windows中的事件的作用)

 

2.条件变量的初始化

      int pthread_cond_init __P ((pthread_cond_t *__cond,__const pthread_condattr_t *__cond_attr));
　　其中cond是一个指向结构pthread_cond_t的指针，cond_attr是一个指向结构pthread_condattr_t的指针。结构pthread_condattr_t是条件变量的属性结构，和互斥锁一样我们可以用它来设置条件变量是进程内可用还是进程间可用，默认值是PTHREAD_ PROCESS_PRIVATE，即此条件变量被同一进程内的各个线程使用。注意初始化条件变量只有未被使用时才能重新初始化或被释放。

 

3.条件变量的释放

释放一个条件变量的函数为pthread_cond_ destroy（pthread_cond_t cond）

 

4.条件变量的等待

      （1）函数pthread_cond_wait（）使线程阻塞在一个条件变量上。它的函数原型为：
　　extern int pthread_cond_wait_P ((pthread_cond_t *__cond,pthread_mutex_t *__mutex));
　　线程解开mutex指向的锁并被条件变量cond阻塞。线程可以被函数pthread_cond_signal和函数pthread_cond_broadcast唤醒，但是要注意的是，条件变量只是起阻塞和唤醒线程的作用，具体的判断条件还需用户给出，例如一个变量是否为0等等，这一点我们从后面的例子中可以看到。线程被唤醒后，它将重新检查判断条件是否满足，如果还不满足，一般说来线程应该仍阻塞在这里，被等待被下一次唤醒。这个过程一般用while语句实现。
　　（2）另一个用来阻塞线程的函数是pthread_cond_timedwait（），它的原型为：
　　extern int pthread_cond_timedwait_P (pthread_cond_t *__cond,

                                                                    pthread_mutex_t *__mutex, __const struct timespec *__abstime);
　　它比函数pthread_cond_wait（）多了一个时间参数，经历abstime段时间后，即使条件变量不满足，阻塞也被解除。

5.条件变量的解除改变

      函数pthread_cond_signal（）的原型为：
　　extern int pthread_cond_signal_P ((pthread_cond_t *__cond));
　　它用来释放被阻塞在条件变量cond上的一个线程。多个线程阻塞在此条件变量上时，哪一个线程被唤醒是由线程的调度策略  所决定的。要注意的是，必须用保护条件变量的互斥锁来保护这个函数，否则条件满足信号又可能在测试条件和调用pthread_cond_wait函数之间被发出，从而造成无限制的等待。

 

6.下面是使用函数pthread_cond_wait（）和函数pthread_cond_signal（）的一个简单的例子。
pthread_mutex_t count_lock;
pthread_cond_t count_nonzero;
unsigned count;
decrement_count　() {
pthread_mutex_lock (&count_lock);
while(count==0) 
pthread_cond_wait( &count_nonzero, &count_lock);
count=count -1;
pthread_mutex_unlock (&count_lock);
}

increment_count(){
pthread_mutex_lock(&count_lock);
if(count==0)
pthread_cond_signal(&count_nonzero);
count=count+1;
pthread_mutex_unlock(&count_lock);
}
　　

count值为0时，decrement函数在pthread_cond_wait处被阻塞，并打开互斥锁count_lock。此时，当调用到函数increment_count时，pthread_cond_signal（）函数改变条件变量，告知decrement_count（）停止阻塞。

有的时候仅仅依靠锁住共享资源来使用它是不够的。有时候共享资源只有某些状态的时候才能够使用。比方说，某个线程如果要从堆栈中读取数据，那么如果栈中没有数据就必须等待数据被压栈。这种情况下的同步使用互斥锁

是不够的。另一种同步的方式－－条件变量，就可以使用在这种情况下。

条件变量的使用总是和互斥锁及共享资源联系在一起的。线程首先锁住互斥锁，然后检验共享资源的状态是否处于可使用的状态。如果不是，那么线程就要等待条件变量。要指向这样的操作就必须在等待的时候将互斥锁解锁，以

便其他线程可以访问共享资源并改变其状态。它还得保证从等到得线程返回时互斥体是被上锁得。当另一个线程改变了共享资源的状态时，它就要通知正在等待条件变量的线程，使之重新变回被互斥锁阻塞的线程。

请看下面的例子：

#include <stdio.h>  
#include <stdlib.h>  
#include <pthread.h>  
  
pthread_mutex_t cond_mutex=PTHREAD_MUTEX_INITIALIZER;  
pthread_cond_t cond_var=PTHREAD_COND_INITIALIZER;  
  
void* function_cond1();  
void* function_cond2();  
  
int count=0;  
#define COUNT_DONE  10  
#define COUNT_HALT1  3  
#define COUNT_HALT2  6  
  
int main()  
{     
    pthread_t thread1,thread2;  
    pthread_create(&thread1,NULL,function_cond1,NULL);  
    pthread_create(&thread2,NULL,function_cond2,NULL);  
      
    pthread_join(thread1,NULL);  
    pthread_join(thread2,NULL);  
      
    printf("Final count: %d\n",count);  
    return 0;  
}  
  
void* function_cond1()  
{  
    for(;;)  
    {  
        pthread_mutex_lock(&cond_mutex);  
        pthread_cond_wait(&cond_var,&cond_mutex);  
        count++;  
        printf("Counter value functionCount1: %d\n",count);  
        pthread_mutex_unlock(&cond_mutex);  
        if(count>=COUNT_DONE) return ;  
    }  
}  
  
void* function_cond2()  
{  
    for(;;)  
    {  
        pthread_mutex_lock(&cond_mutex);  
        if(count<COUNT_HALT1||count>COUNT_HALT2)  
        {  
            // Condition of if statement has been met.  
          // Signal to free waiting thread by freeing the mutex.  
          // Note: functionCount1() is now permitted to modify "count".  
           pthread_cond_signal(&cond_var);  
        }  
        else  
        {  
            count++;  
            printf("Counter value functionCount2: %d\n",count);   
        }  
        pthread_mutex_unlock(&cond_mutex);  
        if(count>=COUNT_DONE) return ;     
    }  
}  

结果：

 

两个线程同时运行，当在count<COUNT_HALT1||count>COUNT_HALT2的时候，线程1是一直等待的。只有线程2条件到达的时候，调用pthread_cond_signal(&cond_var);通知

线程1，pthread_cond_wait(&cond_var,&cond_mutex);