线程间同步形式
- 引言
- 互斥锁
  - 探索底层，实现一个锁
    - 测试并加锁(TAS)
    - 比拟并替换(CAS)
    - 另一个问题，过多的自旋？
  - 回到互斥锁
- 信号量
  - 有名信号量
  - 无名信号量
  - 总结
- 条件变量
  - 什么是条件变量？
  - 相干函数
    - 1. 初始化
    - 2. 期待条件
    - 3. 告诉条件
  - 用法与思考
- 实际——读写者锁

文章已收录至我的仓库：Java学习笔记与收费书籍分享

线程间同步形式

引言

不同线程间对临界区资源的拜访可能会引起常见的并发问题，咱们心愿线程原子式的执行一系列指令，但因为单处理器上的中断，咱们必须想一些其余方法以同步各线程，本文就来介绍一些线程间的同步形式。

互斥锁

互斥锁(又名互斥量)，强调的是资源的拜访互斥：互斥锁是用在多线程多任务互斥的，当一个线程占用了某一个资源，那么别的线程就无法访问，直到这个线程unlock，其余的线程才开始能够利用这个资源。

int pthread_mutex_lock(pthread_mutex_t *mutex);int pthread_mutex_trylock(pthread_mutex_t *mutex);int pthread_mutex_unlock(pthread_mutex_t *mutex);

留神了解trylock函数，这与一般的lock不一样，一般的lock函数在资源被锁住时会被梗塞，直到锁被开释。

trylock函数是非阻塞调用模式，也就是说如果互斥量没被锁住，trylock函数将把互斥量加锁，并取得对共享资源的拜访权限; 如果互斥量被锁住了，trylock函数将不会阻塞期待而间接返回EBUSY，示意共享资源处于忙状态，这样就能够防止死锁或饿死等一些极其状况产生。

探索底层，实现一个锁

实现一个锁必须须要硬件的反对，因为咱们必须要保障锁也是并发平安的，这就须要硬件反对以保障锁外部是原子实现的。

很容易想到保护一个全局变量flag，当该变量为0时，容许线程加锁，并设置flag为1；否则，线程必须挂起期待，直到flag为0.

typedef struct lock_t {    int flag;}lock_t;void init(lock_t &mutex) {    mutex->flag = 0;}void lock(lock_t &mutex) {    while (mutex->flag == 1) {;} //自旋期待变量为0才可进入    mutex->flag = 1;}void unlock(lock_t &mutex) {    mutex->flag = 0;}

这是基于软件的初步实现，初始化变量为0，线程自旋期待变量为0才可进入，这看上去仿佛并没有什么故障，然而认真思考，这是有问题的：

当线程恰好通过while断定时陷入中断，此时并未设置flag为1，另一个线程闯入，此时flag依然为0，通过while断定进入临界区，此时中断，回到原线程，原线程继续执行，也进入临界区，这就造成了同步问题。

在while循环中，仅仅设置mutex->flag == 1是不够的，只管他是一个原语，咱们必须有更多的代码，同时，当咱们引入更多代码时，咱们必须保障这些代码也是原子的，这就意味着咱们须要硬件的反对。

咱们思考下面代码为什么会失败？起因是当退出while循环时，在这一时刻flag依然为0，这就给了其余线程抢入临界区的机会。

解决办法也很直观 —— 在退出while时，借助硬件反对保障flag被设置为1。

测试并加锁(TAS)

咱们编写如下函数：

int TestAndSet(int *old_ptr, int new) {    int old = *old_ptr;    *old_ptr = new;    return old;}

同时从新设置while循环：

void lock(lock_t &mutex) {    while (TestAndSet(mutex->flag， 1) == 1) {;} //自旋期待变量为0才可进入    mutex->flag = 1;}

这里，咱们借助硬件，保障TestAndSet函数是原子执行的，当初锁能够正确的应用了。当flag为0时，咱们通过while测试时曾经将flag设置为1了，其余线程曾经无奈进入临界区。

比拟并替换(CAS)

咱们编写如下函数：

int CompareAndSwap(int *ptr, int expected, int new) {    int actual = *ptr;    if (actual == expected) {        *ptr = new;    }    return actual;}

同样的，硬件也应该反对CAS原语以保障CAS外部也是平安的，当初从新设置while：

void lock(lock_t &mutex) {    while (CompareAndSwap(mutex->flag， 0， 1) == 1) {;} //自旋期待变量为0才可进入    mutex->flag = 1;}

当初锁能够正确的应用了，当flag为0时，咱们通过while测试时曾经将flag设置为1了，其余线程曾经无奈进入临界区。

此外你可能发现CAS所须要更多的寄存器，在未来钻研synchronozation时，你会发现它的妙处。

另一个问题，过多的自旋？

你可能发现了，只管一个线程未能取得锁，其依然在一直while循环以占用CPU资源，一个方法就是当线程未能取得锁，进入休眠以开释CPU资源(条件变量)，当一个线程开释锁时，唤醒一个正在休眠的线程。不过这样也有毛病，进入休眠与唤醒一个锁也是须要工夫的，当一个线程很快就能开释锁时，多等等是比陷入休眠更好的抉择。

Linux下采纳两阶段锁，第一阶段线程自旋肯定工夫或次数期待锁的开释，当达到肯定工夫或肯定次数时，进入第二阶段，此时线程进入休眠。

回到互斥锁

互斥锁提供了并发平安的根本保障，互斥锁用于保障对临界区资源的平安拜访，但何时须要拜访资源并不是互斥锁应该思考的事件，这可能是条件变量该思考的事件。

如果线程频繁的加锁和解锁，效率是十分低效的，这也是咱们必须要思考到的一个点。

信号量

信号量并不用来传送资源，而是用来爱护共享资源，了解这一点是很重要的，信号量 s 的示意的含意为同时容许拜访资源的最大线程数量，它是一个全局变量。

在过程中也能够应用信号量，对于信号量的了解过程中与线程中并无太大差别，都是用来爱护资源，对于更多信号量的了解参见这篇文章: JavaLearningNotes/过程间通信形式。

来思考一个下面简略的例子：两个线程同时批改而造成谬误，咱们不思考读者而仅仅思考写者过程，在这个例子中共享资源最多容许一个线程批改资源，因而咱们初始化 s 为1。

开始时，A率先写入资源，此时A调用P(s)，将 s 减一，此时 s = 0，A进入共享区工作。

此时，线程B也想进入共享区批改资源，它调用P(s)发现此时s为0，于是挂起线程，退出期待队列。

A工作结束，调用V(s)，它发现s为0并检测到期待队列不为空，于是它随机唤醒一个期待线程，并将s加1，这里唤醒了B。

B被唤醒，继续执行P操作，此时s不为0，B胜利执行将s置为0并进入工作区。

此时C想要进入工作区......

能够发现，在无论何时只有一个线程可能访问共享资源，这就是信号量做的事件，他管制进入共享区的最大过程数量，这取决于初始化s的值。尔后，在进入共享区之前调用P操作，出共享区后调用V操作，这就是信号量的思维。

有名信号量

有名信号量以文件的模式存在，即时是不同过程间的线程也能够拜访该信号量，因而能够用于不同过程间的多线程间的互斥与同步。

创立关上有名信号量

sem_t *sem_open(const char *name, int oflag);sem_t *sem_open(const char *name, int oflag, mode_t mode, unsigned int value);//胜利返回信号量指针；失败返回SEM_FAILED，设置errno

name是文件路径名，value设置为信号量的初始值。

敞开信号量，过程终止时，会调用它

int sem_close(sem_t *sem);    //胜利返回0；失败返回-1，设置errno

删除信号量，立刻删除信号量名字，当其余过程都敞开它时，销毁它

int sem_unlink(const char *name);

期待信号量，测试信号量的值，如果其值小于或等于0，那么就期待（阻塞）；一旦其值变为大于0就将它减1，并返回

int sem_wait(sem_t *sem);int sem_trywait(sem_t *sem);//胜利返回0；失败返回-1，设置errno

当信号量的值为0时，sem_trywait立刻返回，设置errno为EAGAIN。如果被某个信号中断，sem_wait会过早地返回，设置errno为EINTR

发出信号量，给它的值加1，而后唤醒正在期待该信号量的过程或线程

int sem_post(sem_t *sem);

胜利返回0；失败返回-1，不会扭转它的值，设置errno，该函数是异步信号平安的，能够在信号处理程序里调用它

无名信号量

无名信号量存在于过程内的虚拟空间中，对于其余过程是不可见的，因而无名信号量用于一个过程体内各线程间的互斥和同步,应用如下API：

（1）sem_init 性能：用于创立一个信号量，并初始化信号量的值。函数原型：

int sem_init (sem_t* sem, int pshared, unsigned int value);

函数传入值： sem:信号量。pshared:决定信号量是否在几个过程间共享。因为目前LINUX还没有实现过程间共享信息量，所以这个值只能取0。

（2）其余函数

int sem_wait       (sem_t* sem);int sem_trywait   (sem_t* sem);int sem_post       (sem_t* sem);int sem_getvalue (sem_t* sem);int sem_destroy   (sem_t* sem);

性能：

sem_wait和sem_trywait相当于P操作，它们都能将信号量的值减一，两者的区别在于若信号量的值小于零时，sem_wait将会阻塞过程，而sem_trywait则会立刻返回。

sem_post相当于V操作，它将信号量的值加一，同时收回唤醒的信号给期待的线程。

sem_getvalue 失去信号量的值。

sem_destroy 捣毁信号量。

如果某个基于内存的信号量是在不同过程间同步的，该信号灯必须寄存在共享内存区中，这要只有该共享内存区存在，该信号灯就存在。

总结

无名信号量存在于内存中，有名信号量是存在于磁盘上的，因而无名信号量的速度更快，但只实用于一个独立过程内的各线程；有名信号量能够速度欠缺，但能够使不同过程间的线程同步，这是通过共享内存实现的，共享内存是过程间的一种通信形式。

你可能发现了，当信号量的值s为1时，信号量的作用于互斥锁的作用是一样的，互斥锁只能容许一个线程进入临界区，而信号量容许更多的线程进入临界区，这取决于信号量的值为多少。

条件变量

什么是条件变量？

在互斥锁中，线程期待flag为0能力进入临界区；信号量中P操作也要期待s不为0......在多线程中，一个线程期待某个条件是很常见的，互斥锁实现一节中，咱们采纳自旋是否有一个更专门、更高效的形式实现条件的期待？

它就是条件变量！条件变量(condition variable)是利用线程间共享的全局变量进行同步的一种机制，次要包含两个动作：一个线程期待某个条件为真，而将本人挂起；另一个线程设置条件为真，并告诉期待的线程持续。

因为某个条件是全局变量，因而条件变量常应用互斥锁以爱护(这是必须的，是被强制要求的)。

条件变量与互斥量一起应用时，容许线程以无竞争的形式期待特定的条件产生。

线程能够应用条件变量来期待某个条件为真，留神了解并不是期待条件变量为真，条件变量(cond)是在多线程程序中用来实现"期待-->唤醒"逻辑罕用的办法，用于保护一个条件(与是条件变量不同的概念)，并不是说期待条件变量为真或为假。条件变量是一个显式的队列，当条件不满足时，线程将本人退出期待队列，同时开释持有的互斥锁；当一个线程扭转条件时，能够唤醒一个或多个期待线程(留神此时条件不肯定为真)。

在条件变量上有两种基本操作：

期待（wait）：一个线程处于期待队列中休眠，此时线程不会占用互斥量，当线程被唤醒后，从新取得互斥锁(可能是多个线程竞争)，并从新取得互斥量。
告诉（signal/notify）：当条件更改时，另一个线程发送告诉以唤醒期待队列中的线程。

相干函数

1. 初始化

条件变量采纳的数据类型是pthread_cond_t,，在应用之前必须要进行初始化,，这包含两种形式:

动态: 间接设置条件变量cond为常量PTHREAD_COND_INITIALIZER。

动静: pthread_cond_init函数, 是开释动静条件变量的内存空间之前, 要用pthread_cond_destroy对其进行清理。

int pthread_cond_init(pthread_cond_t *restrict cond, pthread_condattr_t *restrict attr);int pthread_cond_destroy(pthread_cond_t *cond);//胜利则返回0, 出错则返回谬误编号.

留神：条件变量占用的空间并未被开释。

cond：要初始化的条件变量；attr：个别为NULL。

2. 期待条件

int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restric mutex);int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, const struct timespec *restrict timeout);//胜利则返回0, 出错则返回谬误编号.

这两个函数别离是阻塞期待和超时期待，梗塞等到进入期待队列休眠直到条件批改而被唤醒；超时期待在休眠肯定工夫后主动醒来。

进入期待时线程开释互斥锁，而在被唤醒时线程从新取得锁。

3. 告诉条件

int pthread_cond_signal(pthread_cond_t *cond);int pthread_cond_broadcast(pthread_cond_t *cond);//胜利则返回0, 出错则返回谬误编号.

这两个函数用于告诉线程条件已被批改，调用这两个函数向线程或条件发送信号。

用法与思考

条件变量用法模板：

pthread_cond_t cond;  //条件变量mutex_t mutex;    //互斥锁int flag; //条件//A线程void threadA() {    Pthread_mutex_lock(&mutex);  //爱护临界资源，因为线程会批改全局条件flag    while (flag == 1) //期待某条件成立        Pthread_cond_wait(&cond, &mutex);  //不成立则退出队列休眠，并开释锁    ....dosomthing    ....change flag   //条件被批改    Pthread_cond_signal(&cond); //发送信号告诉条件被批改    Pthread_mutex_unlock(&mutex); //放松信号后尽量疾速开释锁，因为被唤醒的线程会尝试取得锁}//B线程void threadB() {    Pthread_mutex_lock(&mutex);  //爱护临界资源    while (flag == 0) //期待某条件成立        Pthread_cond_wait(&cond, &mutex);  //不成立则退出队列休眠，并开释锁    ....dosomthing    ....change flag   //条件被批改    Pthread_cond_signal(&cond); //放松信号后尽量疾速开释锁，因为被唤醒的线程会尝试取得锁    Pthread_mutex_unlock(&mutex);}

通过下面的一个例子，应该很好了解条件变量与条件的区别，条件变量是一个逻辑，它并不是while循环里的bool语句，我置信很多初学者都有这么一个误区，即条件变量就是线程须要期待的条件。条件是条件，线程期待条件而不是期待条件变量，条件变量使得线程更高效的期待条件成立，是一组期待 — 唤醒的逻辑。

留神这里依然要应用while循环期待条件，你可能会认为明明曾经上锁了别的线程无奈强入。事实上当线程A陷入休眠时会开释锁，而当其被唤醒时，会尝试取得锁，而正在其尝试取得锁时，另一个线程B当初尝试取得锁，并且抢到锁进入临界区，而后批改条件，使得线程A的条件不再成立，线程B返回，此时线程A终于取得锁了，并进入临界区，但此时线程A的条件基本曾经不成立，他不该进入临界区！

此外，被唤醒也不代表条件成立了，例如上述代码线程B批改flag = 3，并且唤醒线程A，这里线程A的条件基本不合乎，所以必须反复断定条件。互斥锁和条件变量的例子通知咱们：在期待条件时，总是应用while而不是if！

陷入休眠的线程必须开释锁也是有意义的，如果不开释锁，其余线程根本无法批改条件，休眠的线程永远都不会醒过来！

实际——读写者锁

读取锁——共享；写入锁——独占。即：读线程能够加多个，而写线程只能有一个，并且读者和写者不能同时工作。

这种状况下因为容许多个读者共享临界区效率会高效，咱们来思考实现的问题：只容许一个写者工作，那么肯定须要一个互斥量或二值信号量来保护，咱们称为写者锁；因为读者和写者不能同时工作，第一个读者必须尝试获取写者锁，而一旦读者数量大于1，则后续读者毋庸尝试获取写者锁而可间接进入，留神到这里存在全局读者数量变量，因而读者也须要一个锁以保护全局读者数量，最初一个退出的读者必须负责开释读者锁。

通晓原理，快去本人入手实现一个读写者锁把！

Linux下通过pthread_rwlock函数族实现。