假设有共享的资源sum,与之相关联的mutex 是lock_s.假设每个线程对sum的操作很简单的,与sum的状态无关,比如只是sum++.那么只用mutex足够了.程序员只要确保每个线程操作前,取得lock,然后sum++,再unlock即可.每个线程的代码将像这样

        add()
       {
　　 pthread_mutex_lock(lock_s);
　　 sum++;
　　 pthread_mutex_unlock(lock_s);
       }

　　如果操作比较复杂,假设线程t0,t1,t2的操作是sum++,而线程t3则是在sum到达100的时候,打印出一条信息,并对sum清零.这种情况下,如果只用mutex, 则t3需要一个循环,每个循环里先取得lock_s,然后检查sum的状态,如果sum>=100,则打印并清零,然后unlock.如果sum<100,则unlock,并sleep()本线程合适的一段时间.

　这个时候,t0,t1,t2的代码不变,t3的代码如下
　　print()
　　{
　　　　while (1)
　　　　{
　　　　　　pthread_mutex_lock(lock_s);
　　　　　　if(sum>=100)
　　　　　　{
　　　　　　　　printf(“sum has reached 100!”);
　　　　　　　　pthread_mutex_unlock(lock_s);
　　　　　　}
　　　　　　else
　　　　　　{
　　　　　　　　pthread_mutex_unlock(lock_s);
　　　　　　　　my_thread_sleep(100);
　　　　　　　　return OK;
　　　　　　}
　　　　}
　　}
这种办法有两个问题
　　1) sum在大多数情况下不会到达100,那么对t3的代码来说,大多数情况下,走的是else分支,只是lock和unlock,然后sleep().这浪费了CPU处理时间.
　　2) 为了节省CPU处理时间,t3会在探测到sum没到达100的时候sleep()一段时间.这样却又带来另外一个问题,亦即t3响应速度下降.可能在sum到达200的时候,t3才会醒过来.
　　3) 这样,程序员在设置sleep()时间的时候陷入两难境地,设置得太短了节省不了资源,太长了又降低响应速度.真是难办啊!

　　这个时候,condition variable外裤内穿,从天而降,拯救了焦头烂额的你.

　　你首先定义一个condition variable.
　　pthread_cond_t cond_sum_ready=PTHREAD_COND_INITIALIZER;

　　t0,t1,t2的代码只要后面加两行,像这样
　　add()
　　{
　　　　pthread_mutex_lock(lock_s);
　　　　sum++;
　　　　pthread_mutex_unlock(lock_s);
　　　　if(sum>=100)
　　　　pthread_cond_signal(&cond_sum_ready);
　　}
　　而t3的代码则是
　　print
　　{
　　　　pthread_mutex_lock(lock_s);
　　　　while(sum<100)
　　　　pthread_cond_wait(&cond_sum_ready, &lock_s);
　　　　printf(“sum is over 100!”);
　　　　sum=0;
　　　　pthread_mutex_unlock(lock_s);
　　　　return OK;
　　}
     注意两点:
　　1) 在thread_cond_wait()之前,必须先lock相关联的mutex, 因为假如目标条件未满足,pthread_cond_wait()实际上会unlock该mutex, 然后block,当目标变量被唤醒的时候才会再重新lock该mutex, 然后返回.

　　2) 为什么是while(sum<100),而不是if(sum<100) ?这是因为在pthread_cond_signal()和pthread_cond_wait()返回之间,有时间差,假设在这个时间差内,还有另外一个线程t4又把sum减少到100以下了,那么t3在pthread_cond_wait()返回之后,显然应该再检查一遍sum的大小.这就是用while的用意,如果sum减少到了100以下,就会再次进入pthread_cond_wait方法.
      

       条件变量使我们可以睡眠等待某种条件出现。
       条件变量是利用线程间共享的全局变量进行同步的一种机制，主要包括两个动作：一个线程等待"条件变量的激活"而挂起；另一个线程使"条件变量激活"。为了防止竞争，条件变量的使用总是和一个互斥锁结合在一起。
条件变量类型为pthread_cond_t

整个pthread_cond_wait（＆mycond,&mymutex）函数的工作流程：
第一个线程首先调用：
    pthread_mutex_lock(&mymutex);
然后，它检查了列表。没有找到感兴趣的东西，于是它调用：
    pthread_cond_wait(&mycond, &mymutex);
然后，pthread_cond_wait() 调用在返回前执行许多操作：
    pthread_mutex_unlock(&mymutex);
它对 mymutex 解锁，然后进入睡眠状态，等待 mycond 以接收 POSIX 线程“信号”。一旦接收到“信号”（加引号是因为我们并不是在讨论传统的 UNIX 信号，而是来自 pthread_cond_signal() 或 pthread_cond_broadcast() 调用的信号），它就会苏醒。但 pthread_cond_wait() 没有立即返回 -- 它还要做一件事：重新锁定 mutex：
    pthread_mutex_lock(&mymutex);
pthread_cond_wait() 知道我们在查找 mymutex “背后”的变化，因此它继续操作，为我们锁定互斥对象，然后才返回。（以上步骤全为原子操作）

创建和注销
        条件变量和互斥锁一样，都有静态动态两种创建方式，静态方式使用PTHREAD_COND_INITIALIZER常量，如下：
        pthread_cond_t cond=PTHREAD_COND_INITIALIZER

        动态方式调用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。API定义如下：
        int pthread_cond_destroy(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)
        等待条件有两种方式：无条件等待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()前的加锁动作对应。
        激发条件有两种形式，pthread_cond_signal()激活一个等待该条件的线程，存在多个等待线程时按入队顺序激活其中一个；而pthread_cond_broadcast()则激活所有等待线程。

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

以下示例集中演示了互斥锁和条件变量的结合使用，以及取消对于条件等待动作的影响。在例子中，有两个线程被启动，并等待同一个条件变量，如果不使用退出回 调函数（见范例中的注释部分），则tid2将在pthread_mutex_lock()处永久等待。如果使用回调函数，则tid2的条件等待及主线程的 条件激发都能正常工作。

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
pthread_mutex_t mutex;
pthread_cond_t  cond;

void * child1(void *arg)
{       
    pthread_cleanup_push(pthread_mutex_unlock,&mutex);  /* comment 1 */        
    while(1){
                printf("thread 1 get running \n");
                printf("thread 1 pthread_mutex_lock returns %d\n",pthread_mutex_lock(&mutex));
                sleep(5);
                pthread_cond_wait(&cond,&mutex); 
                printf("thread 1 condition applied\n");
                pthread_mutex_unlock(&mutex);
     }        
    pthread_cleanup_pop(0);     /* comment 2 */
}

void *child2(void *arg){
        while(1){
                sleep(3);               /* comment 3 */
                printf("thread 2 get running.\n");
                printf("thread 2 pthread_mutex_lock returns %d\n",pthread_mutex_lock(&mutex));
                pthread_cond_wait(&cond,&mutex);
                printf("thread 2 condition applied\n");
                pthread_mutex_unlock(&mutex);
                sleep(1);
        }
}

int main(void){
        int tid1,tid2;
        printf("hello, condition variable test\n");
        pthread_mutex_init(&mutex,NULL);
        pthread_cond_init(&cond,NULL);
        pthread_create(&tid1,NULL,child1,NULL);
        pthread_create(&tid2,NULL,child2,NULL);
        do{
                sleep(2);                   /* comment 4 */
                pthread_cancel(tid1);       /* comment 5 */
                sleep(2);                   /* comment 6 */
                pthread_cond_signal(&cond);   
        }while(1);
        sleep(100);
        pthread_exit(0);
}

     如果不做注释5的pthread_cancel()动作，即使没有那些sleep()延时操作，child1和child2都能正常工作。注释3和注释4 的延迟使得child1有时间完成取消动作，从而使child2能在child1退出之后进入请求锁操作。如果没有注释1和注释2的回调函数定义，系统将 挂起在child2请求锁的地方；而如果同时也不做注释3和注释4的延时，child2能在child1完成取消动作以前得到控制，从而顺利执行申请锁的 操作，但却可能挂起在pthread_cond_wait()中，因为其中也有申请mutex的操作,同时child1没有释放mutex就退出了。child1函数给出的是标准的条件变量的使用方 式：回调函数保护，等待条件前锁定，pthread_cond_wait()返回后解锁。

     条件变量机制不是异步信号安全的，也就是说，在信号处理函数中调用pthread_cond_signal()或者pthread_cond_broadcast()很可能引起死锁。