Linux多线程编程(3)

条件变量:

一、什么是条件变量

与互斥锁不同,条件变量是用来等待而不是用来上锁的。条件变量用来自动阻塞一个线程,直到某特殊情况发生为止。通常条件变量和互斥锁同时使用。条件变量使我们可以睡眠等待某种条件出现。条件变量是利用线程间共享的全局变量进行同步的一种机制,主要包括两个动作:一个线程等待"条件变量的条件成立"而挂起;另一个线程使"条件成立"(给出条件成立信号)。条件的检测是在互斥锁的保护下进行的。如果一个条件为假,一个线程自动阻塞,并释放等待状态改变的互斥锁。如果另一个线程改变了条件,它发信号给关联的条件变量,唤醒一个或多个等待它的线程,重新获得互斥锁,重新评价条件。如果两进程共享可读写的内存,条件变量可以被用来实现这两进程间的线程同步。使用条件变量之前要先进行初始化。

可以在单个语句中生成和初始化一个条件变量如:

pthread_cond_t my_condition=PTHREAD_COND_INITIALIZER;(用于进程间线程的通信)。也可以利用函数 pthread_cond_init 动态初始化。

二、条件变量相关函数

1．

名称：	pthread_cond_init
目标：	条件变量初始化
头文件：	#include < pthread.h>
函数原形：	int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);
参数:	cptr  条件变量 attr  条件变量属性
返回值：	成功返回0，出错返回错误编号。

     

 

 

 

 

 

 

pthread_cond_t 用来定义一个条件变量，pthread_cond_init函数可以用来初始化一个条件变量。他使用变量attr所指定的属性来初始化一个条件变量，如果参数attr为空，那么它将使用缺省的属性来设置所指定的条件变量。

2.

名称：	pthread_cond_destroy
目标：	条件变量摧毁
头文件：	#include < pthread.h>
函数原形：	int pthread_cond_destroy(pthread_cond_t *cond);
参数:	cptr  条件变量
返回值：	成功返回0，出错返回错误编号。

      

 

 

 

pthread_cond_destroy函数可以用来摧毁所指定的条件变量，同时将会释放所给它分配的资源。调用该函数的进程也并不要求等待在参数所指定的条件变量上。也就是说没有获得条件变量的情况下，也可以调用该函数。

3.

名称：	pthread_cond_wait/pthread_cond_timedwait
目标：	条件变量等待
头文件：	#include < pthread.h>
函数原形：	int pthread_cond_wait(pthread_cond_t *cond,pthread_mutex_t *mutex); int pthread_cond_timedwait(pthread_cond_t *cond,pthread_mutex_t mytex,const struct timespec *abstime);
参数:	cond 条件变量 mutex 互斥锁
返回值：	成功返回0，出错返回错误编号。

      

 

 

 

 

 

 

第一个参数cond是指向一个条件变量的指针。第二个参数mutex则是指向相关互斥锁的指针。函数pthread_cond_timedwait函数类型与函数pthread_cond_wait的区别在于，如果达到或是超过所引用的参数abstime,它将结束并返回错误ETIME。pthread_cond_timedwait函数的参数abstime指向一个timespec结构。该结构如下：

typedef struct timespec{

       time_t tv_sec;

       long tv_nsex;

}timespec_t;

3.

名称：	pthread_cond_signal/pthread_cond_broadcast
目标：	条件变量通知
头文件：	#include < pthread.h>
函数原形：	int pthread_cond_signal(pthread_cond_t *cond); int pthread_cond_broadcast(pthread_cond_t *cond);
参数:	cond 条件变量
返回值：	成功返回0，出错返回错误编号。

      

 

 

 

 

 

参数cond是对类型为pthread_cond_t的一个条件变量的指针。当调用pthread_cond_signal时一个在相同条件变量上阻塞的线程将被解锁。如果同时有多个线程阻塞，则由调度策略确定接收通知的线程。如果调用pthread_cond_broadcast,则将通知阻塞在这个条件变量上的所有线程。一旦被唤醒，线程仍然会要求互斥锁。如果当前没有线程等待通知，则上面两种调用实际上成为一个空操作。如果参数cond指向非法地址，则返回值EINVAL。

下面是一个简单的例子,我们可以从程序的运行来了解条件变量的作用：

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;/*初始化互斥锁*/
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;/*初始化条件变量*/
void *thread1(void *);
void *thread2(void *);
int i=1;
int main(void)
{
pthread_t t_a;
pthread_t t_b;
pthread_create(&t_a,NULL,thread2,(void *)NULL);/*创建进程 t_a*/
pthread_create(&t_b,NULL,thread1,(void *)NULL); /*创建进程 t_b*/
pthread_join(t_b, NULL);/*等待进程 t_b 结束*/
pthread_mutex_destroy(&mutex);
pthread_cond_destroy(&cond);
exit(0);
}
void *thread1(void *junk)
{
for(i=1;i<=9;i++)
{
pthread_mutex_lock(&mutex);/*锁住互斥量*/
if(i%3==0)
pthread_cond_signal(&cond);/*条件改变,发送信号,通知 t_b 进程*/
else
printf("thead1:%d\n",i);
pthread_mutex_unlock(&mutex);/*解锁互斥量*/
sleep(1);
}
}
void *thread2(void *junk)
{
while(i<9)
{
pthread_mutex_lock(&mutex);
if(i%3!=0)
pthread_cond_wait(&cond,&mutex);/*等待*/
printf("thread2:%d\n",i);
pthread_mutex_unlock(&mutex);
sleep(1);
}
}

结果：
程序创建了 2 个新线程使他们同步运行,实现进程 t_b 打印 20 以内 3 的倍数,t_a 打印其他的数,程序开始线程 t_b 不满足条件等待,线程 t_a 运行使 a 循环加1 并打印。直到 i 为 3 的倍数时,线程 t_a 发送信号通知进程 t_b,这时 t_b 满足条件,打印 i 值。
下面是运行结果:
#gcc  –o cond cond.c  –lpthread
#./cond
thread1:1
thread1:2
thread2:3
thread1:4
thread1:5
thread2:6
thread1:7
thread1:8
thread2:9

下面的程序是经典的生产者/消费者模型：

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#define MAX 5
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER; /*初始化互斥锁*/
pthread_cond_t=PTHREAD_CODE_INITIALIZER; /*初始化条件变量*/
typedef struct{
char buffer[MAX];
int how_many;
}BUFFER;
BUFFER share={“”,0};
char ch=’A’;/*初始化 ch*/
void *read_some(void *);
void *write_some(void *);
int main(void)
{
pthread_t t_read;
pthread_t t_write;
pthread_create(&t_read,NULL,read_some,(void *)NULL); /*创建进程 t_a*/
pthread_create(&t_write,NULL,write_some,(void *)NULL); /*创建进程 t_b*/
pthread_join(t_write,(void **)NULL);
pthread_mutex_destroy(&mutex);
pthread_cond_destroy(&cond);
exit(0);
}
void *read_some(void *junk)
{
int n=0;
printf(“R %2d: starting\n”,pthread_self());
while(ch!=’Z’)
{
pthread_mutex_lock(&lock_it);/*锁住互斥量*/
if(share.how_many!=MAX)
{
share.buffer[share.how_many++]=ch++;/*把字母读入缓存*/
printf(“R %2d:Got char[%c]\n”,pthread_self(),ch-1);/*打印读入字母*/
if(share.how_many==MAX)
{
printf(“R %2d:signaling full\n”,pthread_self());
pthread_cond_signal(&write_it);/*如果缓存中的字母到达了最大值就
发送信号*/
}
pthread_mutex_unlock(&lock_it);/*解锁互斥量*/
}
sleep(1);
printf(“R %2d:Exiting\n”,pthread_self());
return NULL;
}
void *write_some(void *junk)
{
int i;
int n=0;
printf(“w %2d: starting\n”,pthread_self());
while(ch!=’Z’)
{
pthread_mutex_lock(&lock_it);/*锁住互斥量*/
printf(“\nW %2d:Waiting\n”,pthread_self());
while(share.how_many!=MAX)/*如果缓存区字母不等于最大值就等待*/
pthread_cond_wait(&write_it,&lock_it);
printf(“W %2d:writing buffer\n”,pthread_self());
for(i=0;share.buffer[i]&&share.how_many;++i,share.how_many--)
putchar(share.buffer[i]); /*循环输出缓存区字母*/
pthread_mutex_unlock(&lock_it);/*解锁互斥量*/
}
  printf(“W %2d:exiting\n”,pthread_self());
return NULL;
}

程序每读入 5 个字母,打印一遍,并清空缓存区,循环执行直到 Y 为止。
程序运行结果如下:
#gcc  –o readandwrite readandwrite.c  –lpthread
#./readandwrire
R 1082330304: stareing
W 1090718784:string
W 1090718784:Waiting
R 1082330304:Got char[A]
R 1082330304:Got char[B]
R 1082330304:Got char[C]
R 1082330304:Got char[D]
R 1082330304:Got char[E]
R 1082330304:signaling full
W 1090718784:wring buffer
ABCDE
W 1090718784:Waiting
R 1082330304:Got char[F]
..............................

三、条件变量属性
使用条件变量之前要先进行初始化。可以像我们前面那样可静态初始化pthread_cond_t my_condition=PTHREAD_COND_INITIALIZER;

也可以利用函数pthread_cond_init 动态初始化。

条件变量属性类型为 pthread_condattr_t,它们由以下函数初始化或摧毁。

4．

名称:：	pthread_condattr_init/pthread_condattr_destroy
功能：	初始化/回收pthread_condattr_t结构
头文件：	#include <pthread.h>
函数原形：	int pthread_condattr_init(pthread_condattr_t *attr); int pthread_condattr_destroy(pthread_condattr_t *attr);
参数：
返回值：	若成功返回0，若失败返回错误编号。

 

     

 

 

 

 

  

一旦某个条件变量对象被初始化了，我们就可以利用下面函数来查看或修改特定属性了。

5.

名称:：	pthread_condattr_getpshared/pthread_condattr_setpshared
功能：	查看或修改条件变量属性
头文件：	#include <pthread.h>
函数原形：	intpthread_condattr_getpshared(const pthread_condattr_t *attr); intpthread_condattr_setpshared(const pthread_condattr_t *attr,int pshared);
参数：
返回值：	若成功返回0，若失败返回错误编号。

      

 

 

 

 

 

pthread_condattr_getpshared函数在由valptr指向的整数中返回这个属性的当前值，pthread_condattr_setpshared则根据value的值设置这个属性的当前值。value的值可以是PTHREAD_PROCESS_PRIVATE或PTHREAD_PROCESS_SHARED(进程间共享).