线程同步

线程同步

互斥量：从本质上是一把锁，在访问共享资源前对互斥量加锁，在访问完后解锁，
对互斥量加锁后任何其他试图再次对其加锁都会被阻塞，知道当前线程
对互斥量解锁。


互斥量初始化
1）静态初始化
将互斥量设置为PTHREAD_MUTEX_INITIALIZER
或者调用怕pthread_mutex_init函数


2）动态初始化
#include<pthread.h>
int pthread_mutex_init(pthread_mutex_t * mutex, const pthread_mutexattr_t *attr);
成功-- 0，出错--返回错误编号
参数：
attr -- 若设置为NULL，则是默认属性


3）释放锁占的资源
int pthread_mutex_destroy(pthread_mutex_t *mutex);
成功-- 0，出错--返回错误编号


4)对互斥量加锁和解锁
#include<pthread.h>
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
成功--0，出错--返回错误编号


pthread_mutex_trylock函数对互斥量加锁，若互斥量已经被
加锁，则返回出错码EBUSY


5）带有超时的互斥锁函数
#include<pthread.h>
#include<time.h>
int pthread_mutex_timedlock(pthread_mutex_t *mutex, const struct timespec *tsptr);
成功--0，出错--返回错误编号
超时--返回ETIMEDOUT
参数：
tsptr -- 超时指定愿意等待的绝对时间，使用的时候先获取当前时间，然后将当前时间加上
愿意等待是相对时间，得到最终设置的绝对时间。


 
读写锁：读写锁和互斥量相似，不过读写锁提供更高的并行性。读写锁有三种状态：
读模式下加锁、写模式 下加锁、不加锁。一次只有一个线程有写模式的读写
锁，但是可以有多个线程同时占有读模式下的读写锁。
读写锁在写加锁状态时，所有试图对读写锁加锁的线程都会被阻塞；读写锁在读加锁
状态时，可以对读写锁读加锁，但是不能对其写加锁，还是有一点就是当有一个写加锁
线程在阻塞等待时，后面来的读加锁也会被阻塞，这样是为了读锁长期占有读写锁。

1）静态初始化
读写锁设置为 PTHREAD_RWLOCK_INITIALIZER
或者调用怕pthread_rwlock_init函数


2）动态初始化
#include<pthread.h>
int pthread_rwlock_init(pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr);
成功--0，出错--返回错误编号


3）释放锁占的资源
#include<pthread.h>
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
成功--0，出错--返回错误编号


4）对读写锁加锁和解锁
#include<pthread.h>
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
成功--0，出错--返回错误编号


5）带有超时的读写锁函数
#include<time.h>
#include<pthread.h>
int pthread_rwlock_timedrdlock(pthread_rwlock_t *rwlock, const timespec *tsptr);
int pthread_rwlock_timedwrlock(pthread_rwlock_t *rwlock, const timespec *tsptr);
成功--0，出错--返回错误编号
超时--返回ETIMEDOUT



条件变量： 条件变量给线程提供了一个回合的场所。条件变量和互斥量一起使用时，允许线程以
无竞争的方式等待特定的条件发生。条件本身是被互斥量保护的，线程改变条件状态
之前必须首先锁住互斥量。

1）静态初始化
条件变量设置为PTHREAD_COND_INITIALIZER
或者调用怕pthread_cond_init函数


2）动态初始化
#include<pthread.h>
int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);
成功--0，出错--返回错误编号


3）释放锁占的资源
#include<pthread.h>
int pthread_cond_destroy(pthread_cond_t *cond);
成功--0，出错--返回错误编号


4）等待条件变量变为真
#include<pthread.h>
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
int pthread_cond_timewait(pthread_cond_t *cond, pthread_mutex_t *mutex,const struct timespec *tsptr);
成功--0，出错--返回错误编号
超时--返回ETIMEDOUT


5）唤醒等待该条件的线程
#include<pthread.h>
int pthread_cond_signal(pthread_cond_t *cond);
int pthread_cond_broadcast(pthread_cond_t *cond);
成功--0，出错--返回错误编号


pthread_cond_broadcast函数唤醒所有等待此条件的线程，
pthread_cond_signal函数唤醒一个或一个以上等待此条件的线程。