线程学习（三）

生产者与消费者模型：

 生产者抓取数据，将数据放到缓存区​​中，消费者从缓冲区拿到数据进行处理。
​​​​​​​​​​​​
  消费者为什么不直接获取数据，而要经过生产者？
　　　　提高效率，数据安全程度提高。
 特性：

一个场所： 存放资源场所
两类角色： 生产者，消费者
三种关系：（保证资源安全访问）
　　生产者与生产者 ----> 互斥
　　消费者与消费者 ----> 互斥
　　生产者与消费者 ----> 同步&互斥

信号量

  实际上是一个具有等待队列的计数器，它记录了资源的数目。
　　　目的：实现进程/线程的同步与互斥。
　　　Linux中有POSIX标准信号量（库函数实现） 和 system v信号量 （系统调用）

 这里介绍POSIX信号量的使用：
　　　　　　　　　　＃include <semaphore.h>

sem_t	sem_t sem	创建信号量
sem_init	sem_init(sem_t *sem, int pshared, unsigned int value);	初始化
sem_destroy	sem_destroy(sem_t *sem);	销毁
sem_wait	sem_wait(sem_t *sem);	阻塞等待
sem_trywait	sem_trywait(sem_t *sem);	非阻塞等待
sem_timedwait	sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);	阻塞限时等待
sem_post	sem_post(sem_t *sem);	唤醒等待队列中的进程/线程

读写锁

•  为什么有读写锁？

由于互斥锁只能做到读写互斥，而读共享没办法做到，所以有读写锁来完成。

 实现：

write　写的时候判断写计数和读计数，若都为0则可以写操作，否则阻塞。
read　读的时候只能要判断写计数，若为0，则可以读，否则阻塞。

  这里的阻塞与以前不同，以前是死等，这里的阻塞是自旋式（不满足条件，一直循环判断）。所以读写锁就是计数加自旋锁实现的。

•  那为什么要一直等？

因为我们知道等待的时间不长，所以循环判断。

 使用场景： 操作时间短，并且读的操作多，写的操作少。

 特性： 写互斥，读共享（但读与写也互斥），默认读优先。
　　　　 不能等待时间太长，否则过大耗费CPU。

 读写锁接口：
#include <pthread.h>

pthread_rwlock_init	pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr);	初始化
pthread_rwlock_destroy	pthread_rwlock_destroy(pthread_rwlock_t *rwlock);	销毁
pthread_rwlock_rdlock	pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);	获取阻塞性的读锁
pthread_rwlock_tryrdlock	pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);	获取非阻塞性的读锁
pthread_rwlock_wrlock	pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);	获取阻塞性的写锁
pthread_rwlock_trywrlock	pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);	获取非阻塞性的写锁
pthread_rwlock_unlock	pthread_rwlock_unlock(pthread_rwlock_t *rwlock);	解锁
pthread_rwlockattr_init	pthread_rwlockattr_init(pthread_rwlockattr_t *attr);	读写锁变量属性初始化
pthread_rwlockattr_destroy	pthread_rwlockattr_destroy(pthread_rwlockattr_t *attr);	释放读写锁变量
pthread_rwlockattr_setkind_np	pthread_rwlockattr_setkind_np(pthread_rwlockattr_t *attr， int pref);	设置读写锁属性优先级（默认读优先）