线程同步

线程同步

互斥量：从本质上是一把锁，在访问共享资源前对互斥量加锁，在访问完后解锁，

对互斥量加锁后任何其他试图再次对其加锁都会被阻塞，知道当前线程

对互斥量解锁。

互斥量初始化

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函数唤醒一个或一个以上等待此条件的线程。