c++ 多线程锁的应用

c++ 多线程锁的应用

在多线程编程中数据的同步尤为重要，锁的使用可以很好的实现数据的同步；常用的有互斥锁，还有其他锁，包括自旋锁、读写锁、和乐观锁等，在不同的场景可以挑选使用不同的锁；

一、互斥锁和自旋锁

互斥锁和自旋锁时最底层的两种锁，其他高级锁都是基于他们实现的；

互斥锁和自旋锁都可以保证在同一时间，只有一个线程可以访问；当有一个线程加锁后，其他线程加锁就会失败；互斥锁和自旋锁在加锁失败后的处理方式不同：

• 互斥锁：加锁失败后，线程会释放CPU，给其他线程使用；
• 自旋锁：加锁失败后，线程会忙等待，不停尝试过去锁，直到拿到锁；

互斥锁是一种独占锁，当线程A拿到锁后，该锁就被A独占，只要他不释放锁，其他线程就无法获取；线程B去获取锁就会失败，就释放CPU给其他线程，线程B就处于阻塞状态；

互斥锁加锁失败而阻塞的现象是由操作系统内核实现；加锁失败，内核线程会将线程置为休眠状态，等锁被释放后，内核会在合适的时机唤醒线程，当线程获取到锁后，可以继续执行，如下图：

所以互斥锁加锁失败，会让用户态切换到内核态，让内核帮我们切换线程，增加了性能开销成本（线程上下文其切换）

• 线程加锁失败，内核将线程状态从【运行】状态切换为【睡眠】状态，把CPU给其他线程使用
• 当锁释放后，之前【睡眠】状态的线程会变为【就绪】状态，然后内核会在合适的时间把CPU切花到该线程

当两个线程属于同一个进程时，因为虚拟内存是共享的，所以共享的虚拟内存资源保持不动，只需要切换线程私有的堆栈信息、程序计数器等寄存器数据；上下文切换的时间在几纳秒到几微妙之间，如果锁代码的时间比上下文切换的时间短，那性能会大大降低；

所以如果确定被锁住的时间很短，就因该使用自旋锁，而不是互斥锁；

自旋锁通过CPU提供的CAS函数（Compare And Swap），在用户态完成加锁和解锁，减少上下文切换；

自旋锁的加锁步骤：

1. 查看锁的状态，如果锁是空闲的，则执行第二部，否则会处于忙等待；
2. 将锁设置为当前线程持有；

CAS函数将上述两个步骤合成一条硬件指令，即原子操作；

自旋锁在单核CPU 上，需要抢占式的调度器（即不断通过时钟中断一个线程，运行其他线程）。否则，自旋锁在单 CPU 上无法使用，因为一个自旋的线程永远不会放弃 CPU；

自旋锁开销少，在多核系统下一般不会主动产生线程切换，适合异步、协程等在用户态切换请求的编程方式，但如果被锁住的代码执行时间过长，自旋的线程会长时间占用 CPU 资源，所以自旋的时间和被锁住的代码执行的时间是成「正比」的关系，我们需要清楚的知道这一点。

二、读写锁

读写锁分为读锁和写锁两种，若只读共享资源可以加读锁，若需要修改共享资源可以加写锁

读写锁的工作原理

• 当「写锁」没有被线程持有时，多个线程能够并发地持有读锁，这大大提高了共享资源的访问效率，因为「读锁」是用于读取共享资源的场景，所以多个线程同时持有读锁也不会破坏共享资源的数据。
• 但是，一旦「写锁」被线程持有后，读线程的获取读锁的操作会被阻塞，而且其他写线程的获取写锁的操作也会被阻塞。

所以说，写锁是独占锁，因为任何时刻只能有一个线程持有写锁，类似互斥锁和自旋锁，而读锁是共享锁，因为读锁可以被多个线程同时持有。读写锁在读多写少的场景，能发挥出优势。

读写锁还可以分为「读优先锁」和「写优先锁」

读优先锁期望的是，读锁能被更多的线程持有，以便提高读线程的并发性，它的工作方式是：当读线程 A 先持有了读锁，写线程 B 在获取写锁的时候，会被阻塞，并且在阻塞过程中，后续来的读线程 C 仍然可以成功获取读锁，最后直到读线程 A 和 C 释放读锁后，写线程 B 才可以成功获取读锁。如下图：

而写优先锁是优先服务写线程，其工作方式是：当读线程 A 先持有了读锁，写线程 B 在获取写锁的时候，会被阻塞，并且在阻塞过程中，后续来的读线程 C 获取读锁时会失败，于是读线程 C 将被阻塞在获取读锁的操作，这样只要读线程 A 释放读锁后，写线程 B 就可以成功获取读锁。如下图：

读优先锁会造成写线程饿死的线程，而写有限锁会造成读线程饿死的现象；公平读写锁可以解决上述问题；

公平读写锁比较简单的一种方式是：用队列把获取锁的线程排队，不管是写线程还是读线程都按照先进先出的原则加锁即可，这样读线程仍然可以并发，也不会出现「饥饿」的现象。

互斥锁和自旋锁都是最基本的锁，读写锁都可以使用其中一种来实现；

三、乐观锁和悲观锁

上面提到的互斥锁、自旋锁、读写锁都属于悲观锁；

1. 悲观锁：认为多线程共享资源使用概率较高，容易出现冲突，所以访问前，先加锁；
2. 乐观锁：先修改共享资源，再验证是否有冲突；若没有冲突，则完成修改；若有冲突，则放弃本次操作；

乐观锁前程没有加锁，所以也被称为无锁编程；例如在线文档，git，svn等都是使用乐观锁

乐观锁虽然去除了加锁解锁的操作，但是一旦发现冲突，重试的成本非常高，所以只有在冲突概率非常低，且加锁成本非常高的场景时，才考虑使用乐观锁。
https://blog.csdn.net/weixin_39517546/article/details/110591292

条件变量

条件变量是多线程用来实现等待和唤醒逻辑常用的方法，通常是用wait和notify两个操作来配合使用；wait用于紫色挂起线程，notify用于唤醒用wait挂起的线程；
条件变量使用时会出现虚假唤醒和信号线丢失等问题，一般可采用一个while循环检测条件的方式解决该问题，代码如下：

std::mutex mtx;
std::condition_variable cv:
std::vector<int> vec;

void Consumer() {
	std::unique_lock<std::mutex> lock(mtx);
	// while循环判断条件是否成功，可预防虚假环形和信号丢失
	while (vec.empty()) {
		cv.wait(lock);
	}
	// 相关操作
	std::cout << "consumer " << evc.size() << std::endl;
}

void produce() {
	std::unique_lock<std::mutex> lock(mtx);
	vec.push_back(1);
	cv.notify_one();
	std::cout << "produce " << std::endl;
}
int main() {
	std::thread thread_c(Consumer);
	std::thread thread_p(Produce);
	thread_c.detach();
	thread_p.detach();
	return 0;
}

在c++中已又更好的封装方法，只需要调用wait时，在参数中添加好附加条件就行了，其内服已经做好了while循环的判断，如下：

void Consumer() {
	std::unique_lock<std::mutex> lock(mtx);
	cv.wait(lock, [&](){
		return !vec.empty();
	});
	// 相关操作
	std::cout << "consumer " << evc.size() << std::endl;
}