第十一章 线程

线程标识

#include <pthread.h>
int pthread_equal(pthread_t tid1,pthread_t tid2);
pthread_t pthread_self(void);//线程通过这个函数获取自身线程id

线程 ID 是用 pthread_t 数据类型来表示的，实现的时候可以用一个结构来代表 pthread_t 数据类型，所以可移植的操作 系统实现不能把它作为整数处理。因此必须使用一个函数来对两个线程 ID 进行比较。

线程创建

#include <pthread.h>
int pthread_create(pthread_t *restrict tidp,const pthread_attr_t *restrict attr,void *(*start_rtn)(void *),void *restrict arg);//fork
void pthread_exit(void *rval_ptr);//exit
int pthread_join(pthread_t thread,void **rval_ptr);//waitpid
int pthread_cancel(pthread_t tid);//abort
void pthread_cleanup_push(void (*rtn)(void *),void *arg);//atexit
void pthread_cleanup_pop(int execute);

返回线程信息指针，设置线程属性，开始函数地址，以及参数的结构体

FreeBSD 使用指向线程数据结构的指针作为它的线程 ID。

线程终止

单个线程可以通过 3 种方式退出，因此可以在不终止整个进程的情况下，停止它的控制流

（1）线程可以简单地从启动例程中返回，返回值是线程的退出码。

（2）线程可以被同一进程中的其他线程取消。

（3）线程调用 pthread_exit。

线程同步

互斥量 mutex

#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *restrict attr);
int pthread_mutex_destory(pthread_mutex_t *mutex);
//阻塞加锁
int pthread_mutex_lock(pthread_mutex_t *mutex);
//非阻塞加锁
int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);

使用前需要初始化

要用默认的属性初始化互斥量，只需把 attr 设为 NULL

11.10步骤就是 init->抢lock去+1->使用对象->抢lock去-1/destory lock

多个互斥量很容易死锁，需要排序

比如A和B两个互斥量，约定原则，锁A之前必须先锁B，那么所有线程都必须先抢B，如果一个线程抢到了B，由于没人抢A（抢了也会释放，因为没拿到B），所以很容易拿到A去锁，也就是多个互斥量通过约定顺序，使之看成一个互斥量

pthread_mutex_timedlock

#include <pthread.h>
#include <time.h>
int pthread_mutex_timedlock(pthrea_mutex_t *restrict mutex,const struct timespec *restrict tsptr);

读写锁

#include <pthread.h>
int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,const pthread_rwlockattr_t *restrict attr);
int pthread_rwlock_destory(pthread_rwlock_t *rwlock);

int pthread_rwlock_rdlock(thread_rwlock_t *rwlock);
int pthread_rwlock_wrlock(thread_rwlock_t *rwlock);
int pthread_rwlock_unlock(thread_rwlock_t *rwlock);

int pthread_rwlock_tryrdlock(thread_rwlock_t *rwlock);
int pthread_rwlock_trywrlock(thread_rwlock_t *rwlock);

当读写锁处于读模式锁住的状态，而这时有一个线程试图以写模式获取锁时，读写锁通常会阻塞随后的读模式锁请求

带有超时的读写锁

rwlock

#include <pthread.h>
#include <time.h>
int pthread_rwlock_timedrdlock(pthread_rwlock_t *restrict rwlock,const struct timespec *restrict tsptr);
int pthread_rwlock_timedwrlock(pthread_rwlock_t *restrict rwlock,const struct timespec *restrict tsptr);

条件变量

cond

线程在改变条件状态之前必须首先锁住互斥量

#include <pthread.h>
int pthread_cond_init(pthread_conf_t *restrict cond,const pthread_condattr_t *restrict attr);
int pthread_cond_destory(pthread_cond_t *cond);

int pthread_cond_wait(pthread_conf_t *restrict cond,pthread_mutex_t *restrict mutex);
int pthread_cond_timedwait(pthread_conf_t *restrict cond,pthread_mutex_t *restrict mutex,const struct timespec *restrict tsptr);

int pthread_cond_signal(pthread_cond_t *cond);
int pthread_cond_broadcast(pthread_cond_t *cond);

自旋锁

互斥量基本就可以替代自旋锁了

屏障

允许任意数量的线程等待，直到所有的线程完成处理工作， 而线程不需要退出。所有线程达到屏障后可以接着工作。

#include <pthread.h>
int pthread_barrier_init(pthread_barrier_t *restrict barrier,const pthread_barrierattr_t *restrict attr,unsigned int count);

int pthread_barrier_destory(pthread_barrier_t *barrier);

int pthread_barrier_wait(pthread_barrier_t *barrier);