为了允许在线程或进程之间共享数据，同步是必须的，互斥锁和条件变量是同步的基本组成部分．
１．互斥锁
互斥锁是用来保护临界区资源，实际上保护的是临界区中被操纵的数据，互斥锁通常用于保护由多个线程或进程分享的共享数据，一般是一些可供线程间使用的全局变量，来达到线程同步的目的，保证任何时刻只有一个线程或进程在执行其中的代码，
互斥锁的函数：
１．pthread_mutex_init(pthread_mutex_t *mutex,const pthread_mutexattr_t *mutexattr)函数 初始化一个互斥锁 使用互斥锁之前必须进行初始化操作，初始化有两种方法，１．静态赋值法．对于静态分配的互斥锁一般用宏赋值的方式初始化eg:static pthread_mutex_t mutex = PTHREAD_NUTEX_INITALIZER;2.对于动态分配的互斥锁(如调用malloc)或分配在共享内存中，则必须调用int pthread_mutex_init(pthread_mutex_t *mutex,pthread_mutexattr_t *mutexattr)初始化；
函数中的mutexattr是锁的属性：
属性值：PTHREAD_MUTEX_TIMED_NP 普通锁：当一个线程加锁后，其余请求的线程形成等待队列，解锁后按优先级获得锁； PTHREAD_MUTEX_RECURSIVE_NP:嵌套锁，允许一个线程队同一个锁多次加锁，并通过多次unlock 解锁，如果是不同线程请求，则在解锁时重新竞争； PTHREAD_MUTEX_ERRORCHECK_NP: 检错锁:在同一个线程请求同一个锁的情况下，返回EDEADLK,否则执行的动作和类型PTHREAD_MUTEX_TIMED_NP相同； PTHREAD_MUTEX_ADAPTIVE_NP 适应锁：解锁后重新竞争 ２．int pthread_mutex_destroy(pthread_mutex_t *mutex)函数 注销一个互斥锁 清除一个互锁意味着释放它占用的资源，清除锁时要求当前处于开放状态，若锁处于锁定状态，函数返回EBUSY,该函数成功执行返回０． ３．int pthread_mutex_lock（pthread_mutex_t *mutex）函数 加锁，如果不成功，阻塞等待 用pthread_mutex_lock(pthread_mutex_t *mutex)函数加锁时，如果mutex 已经被锁住，当前尝试加锁的线程就会阻塞，直到互斥锁被其它线程释放． 注意：加锁时，不论那种类型的锁，都不可能被两个不同的线程同时得到，其中一个必须等待解锁，在同一进程中的线程，如果加锁后没有解锁，则其它线程将无法在获得该锁． ４． int pthread_mutex_unlock(pthread_mutex_t *mutex); 解锁； 用此函数有两个条件,1.互斥锁必须处于加锁状态，调用本函数的线程必须是给互斥锁加锁的线程； ５．pthread_mutex_trylock(pthread_mutex_t *mutex); 测试锁，如果不成功则立即返回，错误代码为BEBUSY;
２．条件变量：
条件变量是利用线程间共享的全局变量进行同步的一种机制，条件变量宏观上类似于if 语句，符合条件就能执行某段程序，否则只能等待条件成立． 使用条件变量主要包括两个动作：一个等待使用资源的线程＂条件变量被设置为真＂； 另一个线程在使用完资源后＂设置条件为真＂，这样就能保证线程间的同步了，条件变量的操作函数： int pthread_cond_init ( pthread_cond_t *cond,pthread_condattr_t *cond_attr)函数: 其中，cond_attr参数是条件变量的属性，由于没有得到实现，所以它的值通常为NULL; 等待函数有两个： int pthread_cond_wait([pthread_cond_t *cond,pthread_mutex_t *mutex); 该函数释放由mutex指向的互斥锁，同时使当前线程关于cond指向的条件变量阻塞．直到条件信号唤醒，通常条件表达式在互斥锁的保护下求值，如果条件表达式为假，那么线程基于条件变量阻塞，当一个线程改变条件变量的值时，条件变量获得一个信号，使等待条件变量的线程退出阻塞状态． int pthread_cond_timedwait函数和pthread_cond_wait函数用法类似，差别在于pthread_cond_timewait函数将阻塞直到条件变量获得信号或经过由 abstime指定的时间，也就是说，如果在给定时刻的条件前没有满足，就会ETIMEOUT，结束等待． 线程被条件变量阻塞后，可通过函数int pthread_cond_signal(pthread_cond_t *cond); int pthread_cond_broadcast(pthread_cond_t *cond); pthread_cond_signal()激活一个等待条件成立的线程，存在多个等待线程时，按入队顺序激活其中一个，而pthread_cond_broadcast() 则激活所有等待的线程． 当一个条件变量不在使用时，需要将其清除，清除一个条件变量通过调用 int pthread_cond_destroy(pthread_cond_t *cond)来清除，此函数清除由cond指向的条件变量，注意：只有在没有线程的等待的该条件的时候才能清除这个条件变量．否则返回EBUSY. 来看个例子：
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
void my_err(const char * err_string,int line)
{
fprintf(stderr,"line:%d",line);
perror(err_string);
exit(1);
}
typedef struct private_tag
{
pthread_t thread_id;
char *string;
}private_t;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_key_t key;
int count = 0;
void *key_get(void)
{
void *value = NULL;
int status;
value = pthread_getspecific(key);
if(value == NULL)
{
value=malloc(sizeof(pthread_key_t));
if(value == NULL)
{
my_err("malloc",__LINE__);
}
status = pthread_setspecific(key,value);
if(status!=0)
{
my_err("set",__LINE__);
}
}
return value;
}
void *thread_routine(void *arg)
{
private_t value = NULL;
value=(private_t *)key_get();
value->thread_id=pthread_self();
value->string=(char *)arg;
printf("\"%s\" staring.....\n",value->string);
sleep(2);
}
结果:
yang@liu:~/syc/第八章$ ./mutex 条件变量学习！ 线程1正在运行.... 线程1得到了这个条件! 线程2正在运行! 线程2得到了这个条件! 线程2正在运行! 线程2得到了这个条件! 线程2正在运行! 线程2得到了这个条件! 线程2正在运行! 线程2得到了这个条件! 线程1正在运行.... 线程1得到了这个条件!
上面只是运行结果的一部分，从结果可以看出，thread1和thread2通过条件变量同步运行，在线程thread1和thread2中可以看出，条件变量要配合互锁使用，这样可以防止多个线程同时请求pthread_cond_wait. 来看两个例子:实现生产者—消费者问题，先只考虑多个生产者线程之间的同步，直到所有的生产者线程都完成工作以后，才启动消费者线程
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
void *thread1(void *arg)
{
pthread_cleanup_push(pthread_mutex_unlock,&mutex);
while(1)
{
printf("线程1正在运行....\n");
pthread_mutex_lock(&mutex);
pthread_cond_wait(&cond,&mutex);
printf("线程1得到了这个条件!\n");
pthread_mutex_unlock(&mutex);
sleep(4);
}
pthread_cleanup_pop(0);
}
void *thread2(void *arg)
{
while(1)
{
printf("线程2正在运行!\n");
pthread_mutex_lock(&mutex);
pthread_cond_wait(&cond,&mutex);
printf("线程2得到了这个条件!\n");
pthread_mutex_unlock(&mutex);
sleep(1);
}
}
int main(void)
{
pthread_t thid1,thid2;
printf("条件变量学习！\n");
pthread_mutex_init(&mutex,NULL);
pthread_cond_init(&cond,NULL);
pthread_create(&thid1,NULL,(void *)thread1,NULL);
pthread_create(&thid2,NULL,(void *)thread2,NULL);
do{
pthread_cond_signal(&cond);
}while(1);
sleep(50);
pthread_exit(0);
}
结果:
yang@liu:~/syc/第八章$ ./mutexcond 1000000 5 生产者正在工作! 生产者正在工作! 生产者正在工作! 生产者正在工作! 生产者正在工作! count[0] = 206634 count[1] = 209573 count[2] = 188241 count[3] = 197221 count[4] = 198331 消费者正在工作!
可以看出，生产者进程生产完，消费者进程才开始工作！ ２.通过条件变量判断判断，当消费者等待生产者，当生产者有生产时；即唤醒消费者，消费者开始工作．代码如下:
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <errno.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,nthreads,count[MAXNTHREADS];
pthread_t tid_produce[MAXNTHREADS],tid_consume;
if(argc != 3)
{
printf("usage: producongs2 <#itmes> <#threads>.\n");
exit(0);
}
nitems = atoi(argv[1]);
nthreads = atoi(argv[2]);
pthread_setconcurrency(nthreads+1);
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);
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);
}
void *produce(void *arg)
{
printf("producer begins work\n");
for(; ;)
{
pthread_mutex_lock(&shared.mutex);
if(shared.nput >= nitems)
{
pthread_mutex_unlock(&shared.mutex);
return ;
}
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;
printf("consuemer begins work.\n");
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;
}
结果:
yang@liu:~/syc/第八章$ ./mutexcond 1000000 5 producer begins work producer begins work consuemer begins work. producer begins work producer begins work producer begins work count[0] = 182165 count[1] = 207427 count[2] = 183748 count[3] = 236607 count[4] = 190053