Linux | 线程同步的四种方式

Linux下提供了多种方式来处理线程同步，最常用的是 互斥锁、条件变量、信号量和读写锁。

互斥锁

在线程里也有一把锁——互斥锁（mutex），互斥锁是一种简单的加锁的方法来控制对共享资源的访问，互斥锁只有两种状态,即上锁( lock )和解锁( unlock )。

互斥锁的特点

1、原子性：把一个互斥量锁定为一个原子操作，这意味着操作系统（或pthread函数库）保证了如果一个线程锁定了一个互斥量，没有其他线程在同一时间可以成功锁定这个互斥量；

2、唯一性：如果一个线程锁定了一个互斥量，在它解除锁定之前，没有其他线程可以锁定这个互斥量；

3、非繁忙等待：如果一个线程已经锁定了一个互斥量，第二个线程又试图去锁定这个互斥量，则第二个线程将被挂起（不占用任何cpu资源），直到第一个线程解除对这个互斥量的锁定为止，第二个线程则被唤醒并继续执行，同时锁定这个互斥量。

互斥锁的操作流程

1、在访问共享资源后临界区域前，对互斥锁进行加锁；

2、在访问完成后释放互斥锁。

3、对互斥锁进行加锁后，任何其他试图再次对互斥锁加锁的线程将会被阻塞，直到锁被释放。

初始化锁

#include 
int pthread_mutex_init(pthread_mutex_t *restrict mutex,
const pthread_mutexattr_t *restrict attr);
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

其中参数 attr 用于指定锁的属性（见下），如果为NULL则使用缺省属性。
互斥锁的属性在创建锁的时候指定，在Linux Threads实现中仅有一个锁类型属性，不同的锁类型在试图对一个已经被锁定的互斥锁加锁时表现不同。当前有四个值可供选择：

（1）PTHREAD_MUTEX_TIMED_NP，这是缺省值，也就是普通锁。当一个线程加锁以后，其余请求锁的线程将形成一个等待队列，并在解锁后按优先级获得锁。这种锁策略保证了资源分配的公平性。

（2）PTHREAD_MUTEX_RECURSIVE_NP，嵌套锁，允许同一个线程对同一个锁成功获得多次，并通过多次unlock解锁。如果是不同线程请求，则在加锁线程解锁时重新竞争。

（3）PTHREAD_MUTEX_ERRORCHECK_NP，检错锁，如果同一个线程请求同一个锁，则返回EDEADLK，否则与PTHREAD_MUTEX_TIMED_NP类型动作相同。这样就保证当不允许多次加锁时不会出现最简单情况下的死锁。

（4）PTHREAD_MUTEX_ADAPTIVE_NP，适应锁，动作最简单的锁类型，仅等待解锁后重新竞争。

阻塞加锁

int pthread_mutex_lock(pthread_mutex *mutex);

非阻塞加锁

int pthread_mutex_trylock(pthread_mutex_t *mutex);

该函数语义与 pthread_mutex_lock() 类似，不同的是在锁已经被占据时返回 EBUSY 而不是挂起等待。

解锁

int pthread_mutex_unlock(pthread_mutex *mutex);

要求锁是lock状态,并且由加锁线程进行解锁

销毁锁

int pthread_mutex_destroy(pthread_mutex *mutex);

此时锁必需unlock状态,否则返回EBUSY

条件变量

与互斥锁不同，条件变量是用来等待而不是用来上锁的。条件变量用来自动阻塞一个线程，直 到某特殊情况发生为止。通常条件变量和互斥锁同时使用。

条件变量使我们可以睡眠等待某种条件出现。条件变量是利用线程间共享的全局变量进行同步的一种机制，主要包括两个动作：

1、一个线程等待"条件变量的条件成立"而挂起；
2、另一个线程使 “条件成立”（给出条件成立信号）唤醒等待线程。

原理：

条件的检测是在互斥锁的保护下进行的。线程在改变条件状态之前必须首先锁住互斥量。如果一个条件为假，一个线程自动阻塞，并释放等待状态改变的互斥锁。如果另一个线程改变了条件，它发信号给关联的条件变量，唤醒一个或多个等待它的线程，重新获得互斥锁，重新评价条件。如果两进程共享可读写的内存，条件变量 可以被用来实现这两进程间的线程同步。

条件变量的操作流程如下：

1、初始化：init()或者pthread_cond_tcond=PTHREAD_COND_INITIALIER；属性置为NULL；

2、等待条件成立：pthread_wait，pthread_timewait.wait()释放锁,并阻塞等待条件变量为真 timewait()设置等待时间,仍未signal,返回ETIMEOUT(加锁保证只有一个线程wait)；

3、激活条件变量：pthread_cond_signal,pthread_cond_broadcast(激活所有等待线程)

4、清除条件变量：destroy;无线程等待,否则返回EBUSY。

初始化条件变量

#include 
int pthread_cond_init(pthread_cond_t *restrict cond,
const pthread_condattr_t *restrict attr);
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

尽管POSIX标准中为条件变量定义了属性，但在Linux中没有实现，因此cond_attr值通常为NULL，且被忽略。

两个等待函数

1、无条件等待

int pthread_cond_wait(pthread_cond_t *cond,pthread_mutex_t *mutex);

2、计时等待

int pthread_cond_timewait(pthread_cond_t *cond,
pthread_mutex *mutex,const timespec *abstime);

如果在给定时刻前条件没有满足，则返回ETIMEOUT，结束等待，其中abstime以与time()系统调用相同意义的绝对时间形式出现，0表示格林尼治时间1970年1月1日0时0分0秒。

无论哪种等待方式，都必须和一个互斥锁配合，以防止多个线程同时请求竞争条件（Race Condition）。mutex互斥锁必须是普通锁或者适应锁，且在调用pthread_cond_wait()前必须由本线程加锁，而在更新条件等待队列以前，mutex保持锁定状态，并在线程挂起进入等待前解锁。在条件满足从而离开pthread_cond_wait()之前，mutex将被重新加锁，以与进入pthread_cond_wait()前的加锁动作对应。

激发条件

1、激活一个等待该条件的线程（存在多个等待线程时按入队顺序激活其中一个）

int pthread_cond_signal(pthread_cond_t *cond);

2、激活所有等待线程

int pthread_cond_broadcast(pthread_cond_t *cond);

销毁条件变量

int pthread_cond_destroy(pthread_cond_t *cond);

只有在没有线程在该条件变量上等待的时候才能销毁这个条件变量，否则返回EBUSY。

说明

1、pthread_cond_wait 自动解锁互斥量(如同执行了pthread_unlock_mutex)，并等待条件变量触发。这时线程挂起，不占用CPU时间，直到条件变量被触发（变量为ture）。在调用 pthread_cond_wait之前，应用程序必须加锁互斥量。pthread_cond_wait函数返回前，自动重新对互斥量加锁(如同执行了pthread_lock_mutex)。

2、互斥量的解锁和在条件变量上挂起都是自动进行的。因此，在条件变量被触发前，如果所有的线程都要对互斥量加锁，这种机制可保证在线程加锁互斥量和进入等待条件变量期间，条件变量不被触发。条件变量要和互斥量相联结，以避免出现条件竞争，即一个线程预备等待一个条件变量，当它在真正进入等待之前，另一个线程恰好触发了该条件（条件满足信号有可能在测试条件和调用pthread_cond_wait函数（block）之间被发出，从而造成无限制的等待）。

3、条件变量函数不是异步信号安全的，不应当在信号处理程序中进行调用。特别要注意，如果在信号处理程序中调用pthread_cond_signal 或 pthread_cond_boardcast 函数，可能导致调用线程死锁。

https://www.jb51.net/article/102764.htm

信号量

信号量广泛用于进程或线程间的同步和互斥，信号量本质上是一个非负的整数计数器，它被用来控制对公共资源的访问。

编程时可根据操作信号量值的结果判断是否对公共资源具有访问的权限，当信号量值大于 0 时，则可以访问，否则将阻塞。PV 原语是对信号量的操作，一次 P 操作使信号量减１，一次 V 操作使信号量加１。

如同进程一样，线程也可以通过信号量来实现通信，虽然是轻量级的。

线程使用的基本信号量函数有四个：

初始化信号量

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

参数：
sem：指定要初始化的信号量；
pshared：信号量 sem 的共享选项，linux只支持0，表示它是当前进程的局部信号量；
value：信号量 sem 的初始值。

信号量值加1

给参数sem指定的信号量值加1。

#include 
int sem_post(sem_t *sem);

信号量值减1

给参数sem指定的信号量值减1。

#include 
int sem_wait(sem_t *sem);

如果sem所指的信号量的数值为0，函数将会等待直到有其它线程使它不再是0为止。

销毁信号量

销毁指定的信号量。

#include 
int sem_destroy(sem_t *sem);

读写锁

注意事项

1、如果一个线程用读锁锁定了临界区，那么其他线程也可以用读锁来进入临界区，这样就可以多个线程并行操作。但这个时候，如果再进行写锁加锁就会发生阻塞，写锁请求阻塞后，后面如果继续有读锁来请求，这些后来的读锁都会被阻塞 ! 这样避免了读锁长期占用资源，防止写锁饥饿！

2、如果一个线程用写锁锁住了临界区，那么其他线程不管是读锁还是写锁都会发生阻塞！

常用接口

初始化

#include 
int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,
const pthread_rwlockattr_t *restrict attr);

读写加锁

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);

int pthread_rwlock_timedrdlock(pthread_rwlock_t *restrict rwlock, const struct timespec *restrict abs_timeout);
int pthread_rwlock_timedwrlock(pthread_rwlock_t *restrict rwlock, const struct timespec *restrict abs_timeout);

销毁锁

int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);

读写锁可以有3种状态：读模式下加锁状态、写模式加锁状态、不加锁状态。

一次只有一个线程可以占有写模式的读写锁，但是多个线程可以同时占有读模式的读写锁。

读写锁的特点

1、如果有其它线程读数据，则允许其它线程执行读操作，但不允许写操作；
2、如果有其它线程写数据，则其它线程都不允许读、写操作。

读写锁的规则

1、如果某线程申请了读锁，其它线程可以再申请读锁，但不能申请写锁；
2、如果某线程申请了写锁，其它线程不能申请读锁，也不能申请写锁。
3、读写锁是"读模式加锁"时， 既有试图以写模式加锁的线程，也有试图以读模式加锁的线程。那么读写锁会阻塞随后的读模式锁请求。优先满足写模式锁。读锁、写锁并行阻塞，写锁优先级高

读写锁也叫共享-独占锁。当读写锁以读模式锁住时，它是以共享模式锁住的；当它以写模式锁住时，它是以独占模式锁住的。写独占、读共享。

读写锁适合于对数据结构的读次数比写次数多得多的情况。

---

https://www.jb51.net/article/44228.htm