关于c:线程间同步方式详解

线程间同步形式
- 引言
- 互斥锁
  - 探索底层，实现一个锁
    - 测试并加锁(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。

咱们编写如下函数：

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 了，其余线程曾经无奈进入临界区。

咱们编写如下函数：

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）：当条件更改时，另一个线程发送告诉以唤醒期待队列中的线程。

条件变量采纳的数据类型是 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。

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, 出错则返回谬误编号.

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

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

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 函数族实现。

关于c:线程间同步方式详解

线程间同步形式

引言

互斥锁

探索底层，实现一个锁

测试并加锁(TAS)

比拟并替换(CAS)

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

回到互斥锁

信号量

有名信号量

无名信号量

总结

条件变量

什么是条件变量？

相干函数

1. 初始化

2. 期待条件

3. 告诉条件

用法与思考

实际——读写者锁

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）