互斥锁用于上锁，条件变量用于等待

#include <pthread.h>
int pthread_cond_wait(pthread_cont_t *cptr,pthread_mutex_t *mptr);
int pthread_cond_signal(pthread_cond_t *cptr);
int pthread_cond_broadcast(pthread_cond_t *cptr);
int pthread_cond_timedwait(pthread_cond_t *cptr,pthread_mutex *mptr,const struct timespec *abstime);

wait函数原子地执行以下两个动作：
1、给互斥锁解锁
2、把调用线程投入睡眠，直到另外某个线程就本条件调用pthread_cond_signal。
3、然后，在返回前重新给互斥锁上锁（没有获得锁时一直阻塞在这里）。
验证3的例子(运行结果：等3秒后才输出)

#include "unpipc.h"
int lfx=1;
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond=PTHREAD_COND_INITIALIZER;

void* writer(void *);
void* reader(void *);

int
main(int argc, char **argv)
{
        pthread_t wr,rd;
        pthread_create(&wr,NULL,writer,NULL);
        pthread_create(&rd,NULL,reader,NULL);
        pthread_join(wr,NULL);
        pthread_join(rd,NULL);
        exit(0);
}

void* writer(void* arg)
{
        pthread_mutex_lock(&mutex);
        printf("writer is working\n");
        ++lfx;
        pthread_cond_signal(&cond);
        sleep(3);
        pthread_mutex_unlock(&mutex);
}

void* reader(void* arg)
{
        pthread_mutex_lock(&mutex);
        pthread_cond_wait(&cond,&mutex);
        printf("lfx = %d\n",lfx);
        pthread_mutex_unlock(&mutex);
}

例子

#include        "unpipc.h"

#define MAXNITEMS               1000000
#define MAXNTHREADS                     100

                /* globals shared by threads */
int             nitems;                         /* read-only by producer and consumer */
int             buff[MAXNITEMS];
struct {
  pthread_mutex_t       mutex;
  int                           nput;   /* next index to store */
  int                           nval;   /* next value to store */
} put = { PTHREAD_MUTEX_INITIALIZER };

struct {
  pthread_mutex_t       mutex;
  pthread_cond_t        cond;
  int                           nready; /* number ready for consumer */
} nready = { PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER };
/* end globals */

void    *produce(void *), *consume(void *);

/* include main */
int
main(int argc, char **argv)
{
        int                     i, nthreads, count[MAXNTHREADS];
        pthread_t       tid_produce[MAXNTHREADS], tid_consume;

        if (argc != 3)
                err_quit("usage: prodcons6 <#items> <#threads>");
        nitems = min(atoi(argv[1]), MAXNITEMS);
        nthreads = min(atoi(argv[2]), MAXNTHREADS);

        Set_concurrency(nthreads + 1);
                /* 4create all producers and one consumer */
        for (i = 0; i < nthreads; i++) {
                count[i] = 0;
                Pthread_create(&tid_produce[i], NULL, produce, &count[i]);
        }
        Pthread_create(&tid_consume, NULL, consume, NULL);

                /* wait for all producers and the consumer */
        for (i = 0; i < nthreads; i++) {
                Pthread_join(tid_produce[i], NULL);
                printf("count[%d] = %d\n", i, count[i]);
        }
        Pthread_join(tid_consume, NULL);

        exit(0);
}
/* end main */

/* include prodcons */
void *
produce(void *arg)
{
        for ( ; ; ) {
                Pthread_mutex_lock(&put.mutex);
                if (put.nput >= nitems) {
                        Pthread_mutex_unlock(&put.mutex);
                        return(NULL);           /* array is full, we're done */
                }
                buff[put.nput] = put.nval;
                put.nput++;
                put.nval++;
                Pthread_mutex_unlock(&put.mutex);

                Pthread_mutex_lock(&nready.mutex);
                if (nready.nready == 0)
                        Pthread_cond_signal(&nready.cond);
                nready.nready++;
                Pthread_mutex_unlock(&nready.mutex);

                *((int *) arg) += 1;
        }
}

void *
consume(void *arg)
{
        int             i;

        for (i = 0; i < nitems; i++) {
                Pthread_mutex_lock(&nready.mutex);
                while (nready.nready == 0)
                        Pthread_cond_wait(&nready.cond, &nready.mutex);
                nready.nready--;
                Pthread_mutex_unlock(&nready.mutex);

                if (buff[i] != i)
                        printf("buff[%d] = %d\n", i, buff[i]);
        }
        return(NULL);
}
/* end prodcons */