条件变量

NOTE: 以下内容摘自《UNIX网络编程》（卷2），做下记录，方便以后查阅；

互斥锁用于上锁，而条件变量则用于等待，它是同步的另一种形式。

条件变量总是有一个互斥锁与之关联。把调用线程投入睡眠的pthread_cond_wait函数在这么做之前先给所关联的互斥锁解锁，以后某个时刻唤醒该线程前再给该互斥锁上锁。该条件变量由另外某个线程向它发送信号，而这上发送信号的线程既可以只唤醒一个线程（pthread_cond_signal），也可以唤醒等待相应条件为真的所有线程（pthread_cond_broadcast）。

通常用法：

struct
{
    pthread_mutex_t mutex;
    pthread_con_t cond;
    ....
} var = {PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER, ... };
/* 1）发送信号 */
pthread_mutex_lock(&var.mutex);
set cond = true;
pthread_cond_signal(&var.con);
pthread_mutex_unlock(&var.mutex);
/* 2) 等待信号 */
pthread_mutex_lock（&var.mutex);
while (cond == false)
    pthread_cond_wait(&var.cond, &var.mutex);
modify cond;
pthread_mutex_unlock(&var.mutex);

接口汇总如下：

#include <pthread.h>
/* wait and signal. */
int pthread_cond_wait(pthread_cond_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_t *mptr, const struct timespec *abstime);
/* init and destroy. */
int pthread_cond_init(pthread_cond_t *cptr, const pthread_condattr_t *attr);
int pthread_cond_destroy(pthread_cond_t *cptr);
/* attr used. */
/* value = PTHREAD_PROCESS_PRIVATE | PTHREAD_PROCESS_SHARED; */
int pthread_condattr_init(pthread_condattr_t *attr);
int pthread_condattr_destroy(pthread_condattr_t *attr);
int pthread_condattr_getshared(const pthread_condattr_t *attr, int *valptr);
int pthread_condattr_setshared(pthread_condattr_t *attr, int value);

/* 上述接口若执行成功都返回0， 若失败则返回为正的Exxx值。 */

同样，对于静态分配的条件变量，可以使用宏PTHREAD_COND_INITIALIZER初始化；

static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

生产者－消费者问题（producer-consumer)
使用条件变量源码如下：

#ifndef __COMMON_H
#define __COMMON_H

#include <stdio.h>

void err_quit(char *str_err)
{
    printf(str_err);
}

int min(int a, int b)
{
    return (a < b ? a : b);
}

int max(int a, int b)
{
    return (a > b ? a : b); 
}

#endif /* __COMMON_H */

#include "common.h"
#include <pthread.h>

#define MAXNITEMS 1000000
#define MAXNTHREADS 100

int nitems;
struct {
    pthread_mutex_t mutex;
    int buff[MAXNITEMS];
    int nput;
    int nval;
} shared = {
    PTHREAD_MUTEX_INITIALIZER
};

struct 
{
    pthread_mutex_t mutex;
    pthread_cond_t cond;
    int nready;
} nready = {
    PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER
}; 

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

int 
main(int argc, char **argv)
{
    int i;
    int nthreads;
    int count[MAXNTHREADS];

    pthread_t tid_produce[MAXNTHREADS];
    pthread_t tid_consume;

    if (argc != 3)
    {
        err_quit("usage: prodcons2 <#items> <#threads>");
    }

    nitems = min(atoi(argv[1]), MAXNITEMS);
    nthreads = min(atoi(argv[2]), MAXNTHREADS);

    // Set_concurrency(nthreads + 1);

    for (i = 0; i < nthreads; i++)
    {
        count[i] = 0;
        pthread_create(&tid_produce[i], NULL, produce, &count[i]);
    }

    // wait ofr all the producer threads.
    for (i = 0; i < nthreads; i++)
    {
        pthread_join(tid_produce[i], NULL);
        printf("count[%d] = %d\n", i, count[i]);
    }

    // start, then wait for the consumer thread.
    pthread_create(&tid_consume, NULL, consume, NULL);
    pthread_join(tid_consume, NULL);

    return 0;
}

void *
produce(void *arg)
{
    for (;;)
    {
        pthread_mutex_lock(&shared.mutex);
        // array is full, we're done.
        if (shared.nput >= nitems)
        {
            pthread_mutex_unlock(&shared.mutex);
            return NULL;
        }

        shared.buff[shared.nput] = shared.nval;
        shared.nput++;
        shared.nval++;
        pthread_mutex_unlock(&shared.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 (shared.buff[i] != i)
        {
            printf ("buff[%d] = %d\n", i , shared.buff[i]);
        }
    }

    return NULL;
}

编译与运行：

linux$ gcc main.c -lpthread
linux$ ./a.out 1000000 5
count[0] = 212902
count[1] = 173974
count[2] = 252133
count[3] = 209490
count[4] = 151501