一、说明
linux的线程同步涉及：
1、互斥量
2、条件变量
3、信号灯
4、文件读写锁
信号灯很多时候被称为信号量，但个人仍觉得叫做信号灯比较好，因为可以与“SYSTEM V IPC的信号量”相区分(如有不同意见，欢迎探讨)。
二、互斥量
1、定义
互斥锁允许我们锁住某个对象(某个变量、某段代码等)，使得每次只能有一个线程访问他。我们在对需要保护的对象进行操作前，先把互斥锁上锁，如果上锁成功，就不会有别的线程再来操作被保护的对象。如果上锁不成功，线程就会阻塞(可能是有别的线程已经把互斥锁锁住了)，直到互斥锁被打开。从而保护了要保护的对象。
2、相关函数
a.pthread_mutex_init
函数原型：
#include
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t*mutexattr);
功能：初始化互斥锁
参数：mutex为pthread_mutex_t类型的变量的地址，也就是互斥锁的名字；
mutexattr为pthread_mutexattr_t类型的变量地址，用于设置锁的属性，默认可以设为NULL；
返回：成功0，错误返回错误代码。
备注：初始化互斥锁还有个简便的方法，比如对 pthread_mutex_t a; 进行初始化，则直接写成：pthread_mutex_t a = PTHREAD_MUTEX_INITIALIZER; 即可。
b.pthread_mutex_destroy
函数原型：
int pthread_mutex_destroy(pthread_mutex_t *mutex);
功能：销毁互斥锁
参数：mutex为要销毁的互斥锁的地址
返回：成功0，错误返回错误代码。
c.pthread_mutex_lock
函数原型：
int pthread_mutex_lock(pthread_mutex_t *mutex));
功能：上锁
参数：同上
返回：同上
d.pthread_mutex_unlock
函数原型：
int pthread_mutex_unlock(pthread_mutex_t *mutex);
功能：解锁
参数：同上
返回：同上
3、例程
#include
#include
pthread_mutex_t mylock = PTHREAD_MUTEX_INITIALIZER;
int cnt=0;
void *func1(void *b)
{
int a=2000;
usleep(rand()%2000);
while(a--)
{
printf("11111=%d.\n",a);
printf("\tpthread 1 start to lock.\n");
pthread_mutex_lock (&mylock);
printf("\tpthread 1 locked.\n");
cnt++;
printf("\t++cnt=%d\n",cnt);
printf("\tpthread 1 start to unlock.\n");
pthread_mutex_unlock (&mylock);
printf("\tpthread 1 unlocked.\n");
}
}
void *func2(void *b)
{
int a=2000;
usleep(rand()%2000);
while(a--)
{
printf("22222=%d.\n",a);
printf("\tpthread 2 start to lock.\n");
pthread_mutex_lock (&mylock);
printf("\tpthread 2 locked.\n");
if(cnt>0)
{
cnt--;
printf("\t--cnt=%d\n",cnt);
}
printf("\tpthread 2 start to unlock.\n");
pthread_mutex_unlock (&mylock);
printf("\tpthread 2 unlocked.\n");
if(!cnt)
{
usleep(1);
}
}
}
int main(void)
{
pthread_t a,b;
pthread_create(&a, NULL, func1, (void*)0 );
pthread_create(&b, NULL, func2, (void*)0 );
pthread_join (a, NULL);
pthread_join (b, NULL);
return 0;
}程序中，cnt即为要保护的对象，两个线程，同一时刻只能有一个线程在访问这个对象。
三、条件变量
1、定义
条件变量与互斥量一起使用时，允许线程以无竞争的方式等待特定条件的发生。条件本身受互斥量的保护，线程在改变条件状态前，必须先锁住互斥量，其他线程在获得互斥量之前不会觉察到这种变化(因为互斥量被正在改变条件的线程锁着，其他线程没有获得互斥量就没有机会觉察到变化)
2、相关函数
a.pthread_cond_init
函数原型：
int pthread_cond_init (pthread_cond_t * cond,const pthread_condattr_t *cond_attr);
功能：初始化条件变量
参数：cond条件变量名的地址
cond_attr为条件变量的属性
返回：成功0，错误返回错误编号
备注：简便的初始化方法：pthread_cond_t a = PTHREAD_COND_INITIALIZER;
b.pthread_cond_destroy
函数原型：
int pthread_cond_destroy (pthread_cond_t *cond)；
功能：销毁条件变量
参数：cond条件变量名的地址
返回：成功0，错误返回错误代码
c.pthread_cond_wait
函数原型：
int pthread_cond_wait (pthread_cond_t *cond,pthread_mutex_t *mutex);
功能：等待互斥锁mutex下的条件cond的发生
参数：cond为要等待的条件变量
mutex为保护条件变量的互斥锁
返回：成功0，错误返回错误代码
d.pthread_cond_signal
函数原型：
int pthread_cond_signal (pthread_cond_t *cond);
功能：发送条件变量cond
参数：cond为要发送的条件变量
返回：成功0，否则返回错误编号 备注：
只通知某一个等待该条件的线程
e.pthread_cond_broadcast
功能：发送条件变量cond
参数：cond为要发送的条件变量
返回：成功0，否则返回错误编号
备注：通知所有等待该条件的线程
3、例程(与某嵌入式面试题类似：三个线程各自打印A、B、C，要求按顺序ACBCACBC输出)
#include
#include
#include
int sequence=1;
int eat = 1;
pthread_mutex_t productor_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t my_cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t productor_mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t my_cond1 = PTHREAD_COND_INITIALIZER;
void *productor1()
{
int my_sequence = 1;
while(1)
{
pthread_mutex_lock(&productor_mutex);
while(sequence!=my_sequence)
{
pthread_cond_wait (&my_cond, &productor_mutex);
}
pthread_mutex_lock(&productor_mutex1);
while(eat!=1)
{
pthread_cond_wait (&my_cond1, &productor_mutex1);
}
printf("A ");
eat=0;
pthread_cond_broadcast (&my_cond1);
pthread_mutex_unlock (&productor_mutex1);
sequence=2;
pthread_cond_broadcast(&my_cond);
pthread_mutex_unlock (&productor_mutex);
}
return 0;
}
void *productor2()
{
int my_sequence=2;
while(1)
{
pthread_mutex_lock(&productor_mutex);
while(sequence!=my_sequence)
{
pthread_cond_wait (&my_cond, &productor_mutex);
}
pthread_mutex_lock(&productor_mutex1);
while(eat!=1)
{
pthread_cond_wait (&my_cond1, &productor_mutex1);
}
printf("B ");
eat=0;
pthread_cond_broadcast (&my_cond1);
pthread_mutex_unlock (&productor_mutex1);
sequence=1;
pthread_cond_broadcast (&my_cond);
pthread_mutex_unlock (&productor_mutex);
}
return 0;
}
void *consumer()
{
long a=200;
while(a--)
{
pthread_mutex_lock(&productor_mutex1);
while(eat!=0)
{
pthread_cond_wait (&my_cond1, &productor_mutex1);
}
printf("C ");
eat=1;
pthread_cond_broadcast (&my_cond1);
pthread_mutex_unlock (&productor_mutex1);
}
return 0;
}
int main(void)
{
pthread_t pth1=0,pth2=0,pth3=0;
int err=-1;
void *tret=NULL;
err = pthread_create(&pth1,NULL,productor1,NULL);
if(err)
{
printf("creat pthread productor failed!\n");
exit(1);
}
err = pthread_create(&pth2,NULL,productor2,NULL);
if(err)
{
printf("creat pthread productor failed!\n");
exit(1);
}
err = pthread_create(&pth3,NULL,consumer,NULL);
if(err)
{
printf("creat pthread consumer failed!\n");
exit(1);
}
err = pthread_join(pth3,&tret);
if(err)
printf("can't join pthread consumer!\n");
else
printf("pthread consumer exit with %d!\n",(int)tret);
pthread_cancel(pth1);
pthread_cancel(pth2);
exit(0);
}
四、信号灯
1、定义
又叫做计数信号量，post一次信号量的值+1；wait一次，信号量的值-1，如果信号量的值已经为0，则wait将阻塞直至信号量的值>0；
2、相关函数
a.sem_init
函数原型：
#include
int sem_init(sem_t *sem, int pshared, unsigned int value);
功能：初始化信号量
参数：sem为要初始化的信号量地址
value为初始化设置的值
返回：X？
b.sem_destroy
函数原型：
int sem_destroy(sem_t * sem);
功能：销毁信号量
参数：sem要销毁的信号量地址
返回：X？
c.sem_post
函数原型：
int sem_post(sem_t * sem);
功能：信号量值+1
参数：
返回：
d.sem_wait
函数原型：
int sem_wait(sem_t * sem);
功能：信号量值-1
参数：sem要销毁的信号量地址
返回：X？
e.sem_getvalue
函数原型：
int sem_getvalue(sem_t * sem);
功能：获取信号量当前值
参数：
返回：X？
3、例程
五、文件读写锁
1、定义
2、相关函数
3、例程
