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