Linux 下条件变量

1.互斥锁的存在问题：

互斥锁一个明显的缺点是它只有两种状态：锁定和非锁定。设想一种简单情景：多个线程访问同一个共享资源时，并不知道何时应该使用共享资源，如果在临界区里加入判断语句，或者可以有效，但一来效率不高，二来复杂环境下就难以编写了，这是我们需要一个结构，能在条件成立时触发相应线程，进行变量修改和访问。

2.条件变量:

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

3.条件变量的相关函数

头文件：#include <pthread.h>
       pthread_cond_t cond = PTHREAD_COND_INITIALIZER; //条件变量结构
       int    pthread_cond_init(pthread_cond_t    *cond,    pthread_condattr_t
       *cond_attr);
       int pthread_cond_signal(pthread_cond_t *cond);
       int pthread_cond_broadcast(pthread_cond_t *cond);
       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);
       int pthread_cond_destroy(pthread_cond_t *cond);

详细说明：

  （1）创建和注销

条件变量和互斥锁一样，都有静态动态两种创建方式

 a.静态方式

静态方式使用PTHREAD_COND_INITIALIZER常量，如下：
pthread_cond_t cond=PTHREAD_COND_INITIALIZER

 b.动态方式

动态方式调用pthread_cond_init()函数，API定义如下：
int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr)

尽管POSIX标准中为条件变量定义了属性，但在LinuxThreads中没有实现，因此cond_attr值通常为NULL，且被忽略。

注销一个条件变量需要调用pthread_cond_destroy()，只有在没有线程在该条件变量上等待的时候才能注销这个条件变量，否则返回EBUSY。因为Linux实现的条件变量没有分配什么资源，所以注销动作只包括检查是否有等待线程。API定义如下：
int pthread_cond_destroy(pthread_cond_t *cond)

（2）等待和激发

a.等待

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)//有时等待

等待条件有两种方式：无条件等待pthread_cond_wait()和计时等待pthread_cond_timedwait()，其中计时等待方式如果在给定时刻前条件没有满足，则返回ETIMEOUT，结束等待，其中abstime以与time()系统调用相同意义的绝对时间形式出现，0表示格林尼治时间1970年1月1日0时0分0秒。

无论哪种等待方式，都必须和一个互斥锁配合，以防止多个线程同时请求pthread_cond_wait()（或 pthread_cond_timedwait()，下同）的竞争条件（Race Condition）。mutex互斥锁必须是普通锁（PTHREAD_MUTEX_TIMED_NP）或者适应锁（PTHREAD_MUTEX_ADAPTIVE_NP），且在调用pthread_cond_wait()前必须由本线程加锁（pthread_mutex_lock()），而在更新条件等待队列以前，mutex保持锁定状态，并在线程挂起进入等待前解锁。在条件满足从而离开 pthread_cond_wait()之前，mutex将被重新加锁，以与进入pthread_cond_wait()前的加锁动作对应。

b.激发

激发条件有两种形式，pthread_cond_signal()激活一个等待该条件的线程，存在多个等待线程时按入队顺序激活其中一个；而pthread_cond_broadcast()则激活所有等待线程。

（3）． 其他操作

pthread_cond_wait ()和pthread_cond_timedwait()都被实现为取消点，因此，在该处等待的线程将立即重新运行，在重新锁定mutex后离开 pthread_cond_wait()，然后执行取消动作。也就是说如果pthread_cond_wait()被取消，mutex是保持锁定状态的，因而需要定义退出回调函数来为其解锁。

看完基本操作后做一个小练习：

建立两个线程1、2，两个线程分别访问共享资源，并进行加 1操作，当共享资源<=3时，线程1挂起不操作，这时线程2工作，共享资源>3后，两者都工作

view plaincopy to clipboardprint?
/*condmutex.c*/ 
#include <stdlib.h>    
#include <stdio.h>    
#include <pthread.h>    
#include <errno.h>     
 
/*全局变量*/ 
int gnum = 0;  
/*互斥量 */ 
pthread_mutex_t mutex;  
/*条件变量*/ 
pthread_cond_t  cond;  
 
/*声明线程运行服务程序*/ 
static void pthread_func_1 (void);     
static void pthread_func_2 (void);     
 
int main (void)     
{     
    /*线程的标识符*/ 
    pthread_t pt_1 = 0;     
    pthread_t pt_2 = 0;     
    int ret = 0;     
      
    /*互斥初始化*/ 
    pthread_mutex_init (&mutex, NULL);   
    /*条件变量初始化*/ 
    pthread_cond_init(&cond,NULL);  
    /*分别创建线程1、2*/ 
    ret = pthread_create (&pt_1,            //线程标识符指针  
        NULL,           //默认属性  
        (void *)pthread_func_1,//运行函数  
        NULL);          //无参数  
    if (ret != 0)     
    {     
        perror ("pthread_1_create");     
    }     
      
    ret = pthread_create (&pt_2,            //线程标识符指针  
        NULL,           //默认属性    
        (void *)pthread_func_2, //运行函数  
        NULL);          //无参数  
    if (ret != 0)     
    {     
        perror ("pthread_2_create");     
    }     
    /*等待线程1、2的结束*/ 
    pthread_join (pt_1, NULL);     
    pthread_join (pt_2, NULL);     
      
    printf ("main programme exit!/n");    
    return 0;     
}     
 
/*线程1的服务程序*/ 
static void pthread_func_1 (void)     
{     
    int i = 0;     
      
    for (;;)     
    {     
        printf ("This is pthread1!/n");      
        pthread_mutex_lock(&mutex); /*获取互斥锁*/ 
        /*注意，这里以防线程的抢占，以造成一个线程在另一个线程sleep时多次访问互斥资源，所以sleep要在得到互 
 
斥锁后调用*/ 
        sleep (1);  
        /*条件变量，当gnum<=3时，线程1自己挂起并且解锁，让线程2进去*/ 
        while (gnum <= 3) {  
            pthread_cond_wait(&cond, &mutex);  
        }  
        /*当线程2调用pthread_cond_signal(&cond)时，线程1在这里重启*/ 
        /*临界资源*/ 
        gnum++;  
        printf ("Thread1 add one to num:%d/n",gnum);  
        pthread_mutex_unlock(&mutex); /*释放互斥锁*/ 
          
          
          
    }     
}     
/*线程2的服务程序*/   
static void pthread_func_2 (void)     
{     
    int i = 0;     
      
    for (;;)     
    {     
        printf ("This is pthread2!/n");   
        pthread_mutex_lock(&mutex); /*获取互斥锁*/ 
        /*注意，这里以防线程的抢占，以造成一个线程在另一个线程sleep时多次访问互斥资源，所以sleep要在得到互 
 
斥锁后调用*/ 
        sleep (1);  
        /*临界资源*/ 
        gnum++;  
        printf ("Thread2 add one to num:%d/n",gnum);  
        /*当gnum == 4时，触发*/ 
        if (gnum == 4)   
            pthread_cond_signal(&cond);  
          
        pthread_mutex_unlock(&mutex); /*释放互斥锁*/ 
          
    }     
      
    pthread_exit (0);     
}   
/*condmutex.c*/
#include <stdlib.h> 
#include <stdio.h> 
#include <pthread.h> 
#include <errno.h>  

/*全局变量*/
int gnum = 0;
/*互斥量 */
pthread_mutex_t mutex;
/*条件变量*/
pthread_cond_t  cond;

/*声明线程运行服务程序*/
static void pthread_func_1 (void);  
static void pthread_func_2 (void);  

int main (void)  
{  
 /*线程的标识符*/
 pthread_t pt_1 = 0;  
 pthread_t pt_2 = 0;  
 int ret = 0;  
 
 /*互斥初始化*/
 pthread_mutex_init (&mutex, NULL);
 /*条件变量初始化*/
 pthread_cond_init(&cond,NULL);
 /*分别创建线程1、2*/
 ret = pthread_create (&pt_1,   //线程标识符指针
  NULL,   //默认属性
  (void *)pthread_func_1,//运行函数
  NULL);     //无参数
 if (ret != 0)  
 {  
  perror ("pthread_1_create");  
 }  
 
 ret = pthread_create (&pt_2,    //线程标识符指针
  NULL,   //默认属性 
  (void *)pthread_func_2, //运行函数
  NULL);     //无参数
 if (ret != 0)  
 {  
  perror ("pthread_2_create");  
 }  
 /*等待线程1、2的结束*/
 pthread_join (pt_1, NULL);  
 pthread_join (pt_2, NULL);  
 
 printf ("main programme exit!/n"); 
 return 0;  
}  

/*线程1的服务程序*/
static void pthread_func_1 (void)  
{  
 int i = 0;  
 
 for (;;)  
 {  
  printf ("This is pthread1!/n");   
  pthread_mutex_lock(&mutex); /*获取互斥锁*/
  /*注意，这里以防线程的抢占，以造成一个线程在另一个线程sleep时多次访问互斥资源，所以sleep要在得到互

斥锁后调用*/
  sleep (1);
  /*条件变量，当gnum<=3时，线程1自己挂起并且解锁，让线程2进去*/
  while (gnum <= 3) {
   pthread_cond_wait(&cond, &mutex);
  }
  /*当线程2调用pthread_cond_signal(&cond)时，线程1在这里重启*/
  /*临界资源*/
  gnum++;
  printf ("Thread1 add one to num:%d/n",gnum);
  pthread_mutex_unlock(&mutex); /*释放互斥锁*/
  
  
  
 }  
}  
/*线程2的服务程序*/
static void pthread_func_2 (void)  
{  
 int i = 0;  
 
 for (;;)  
 {  
  printf ("This is pthread2!/n");
  pthread_mutex_lock(&mutex); /*获取互斥锁*/
  /*注意，这里以防线程的抢占，以造成一个线程在另一个线程sleep时多次访问互斥资源，所以sleep要在得到互

斥锁后调用*/
  sleep (1);
  /*临界资源*/
  gnum++;
  printf ("Thread2 add one to num:%d/n",gnum);
  /*当gnum == 4时，触发*/
  if (gnum == 4)
   pthread_cond_signal(&cond);
  
  pthread_mutex_unlock(&mutex); /*释放互斥锁*/
  
 }  
 
 pthread_exit (0);  
}  

编译，运行，可以看到预期结果，这里只是一个简单练习，例子不怎么好，以后再深入研究条件变量，用条件变量解决生产者--消费者问题

 

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/benny_cen/archive/2009/03/09/3972903.aspx

 

 

 

pthread_cond_wait 自动解锁互斥量(如同执行了 pthread_unlock_mutex)，并等待条件变量触发。这时线程挂起，不占用 CPU 时间，直到条件变量被触发。在调用 pthread_cond_wait 之前，应用程序必须加锁互斥量。pthread_cond_wait 函数返回前，自动重新对互斥量加锁(如同执行了 pthread_lock_mutex)。

 

举例1.                                                                                    
    设有两个共享的变量 x 和 y，通过互斥量 mut 保护，当 x > y 时，条件变量 cond 被触发。
             int x,y;
             int x,y;
             pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
             pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
                                                                                         
    等待直到 x > y 的执行流程：
              pthread_mutex_lock(&mut);
              while (x <= y) {
                      pthread_cond_wait(&cond, &mut);
              }
              /* 对 x、y 进行操作 */
              pthread_mutex_unlock(&mut);
                                                                                         
     对 x 和 y 的修改可能导致 x > y，应当触发条件变量：                                                                                         
              pthread_mutex_lock(&mut);
              /* 修改 x、y */
              if (x > y) pthread_cond_broadcast(&cond);
              pthread_mutex_unlock(&mut);

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/hiflower/archive/2008/03/18/2195350.aspx