std::mutex和std::lock_guard

std::mutex是互斥锁，它是一种可锁定的对象，它被设计用来在关键代码段需要独占访问时发出信号，防止具有相同保护的其他线程并发执行并访问相同的内存位置。互斥对象提供独占性，不支持递归性(也就是说，一个线程不应该锁定它已经拥有的互斥对象，否则会导致死锁)。  

 构造函数：仅支持默认构造函数，不支持拷贝和移动构造函数。完成构造后，处于unlock状态。互斥锁的构造本身不是原子的:在构造时访问对象可能会引发数据竞争。  

lock()：调用线程锁住互斥对象，必要时阻塞，互斥对象被作为原子操作访问/修改(不会导致数据竞争)。  :

如果互斥锁当前没有被任何线程锁住，调用线程将锁住它(从这一点开始，直到unlock()被调用，线程拥有互斥锁)。  

如果互斥锁当前被另一个线程锁定，调用线程的执行将被阻塞，直到另一个线程执行unlock()(其他非锁定线程继续执行)。  

如果互斥对象当前被调用此函数的同一线程锁定，则会产生死锁(行为未定义)。

互斥锁上的所有锁定和解锁操作都遵循一个总的顺序，在同一对象上的锁定操作和之前的解锁操作之间，所有可见的效果都是同步的。  

trylock(): 如果没有锁定，则锁定互斥对象，功能和lock()类似，只是在trylock()失败时会返回false，同时调用线程不会被阻塞。

如果没有std::mutext mtx的锁定保护，那么*和$的输出不能保证是一次性全输出，大概率会出现交叉现象。

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx;

void print_block(int n, char c){
	mtx.lock();
    for(int i=0; i<n; ++i){
        std::cout << c;
    }
    std::cout <<'\n';
	mtx.unlock();
}

int main(){
    std::thread th1(print_block, 500,'*');
	std::thread th2(print_block, 500,'$');
	
	th1.join();
	th2.join();
	return 0;
}

std::lock_guard是锁保护器，它通过保持互斥对象始终处于锁定状态来管理互斥对象。在构造时，互斥对象被调用线程锁定，而在销毁时，互斥对象被解锁。 它是最简单的锁，特别适用于具有自动持续时间(duration)的对象，该对象持续到上下文结束。 通过这种方式，它保证在抛出异常时正确地解锁互斥对象。注意，lock_guard对象不以任何方式管理互斥对象的生存期:互斥对象的生存期至少要延长到锁它的lock_guard被销毁。

下面的代码段如果用mtx.lock()替换std::lock_guard<std::mutex> lck(mtx);的话，会在抛出异常后因为不能执行unlock()操作而死锁。

#include <iostream>
#include <thread>
#include <mutex>
#include <stdexcept>


std::mutex mtx;

void print_even(int x){
	std::lock_guard<std::mutex> lck(mtx);
	if(x%2==0){
		std::cout << x << " is even\n";
	}else{
		throw (std::logic_error("not even"));
	}
}

void print_thread_id(int id) {
	try{
			print_even(id);
	}
	catch (std::logic_error&) {
		std::cout << "[exception caught]\n";
	}
}

int main(){
    std::thread threads[10];
	
	for(int i=0; i<10; ++i)
		threads[i] = std::thread(print_thread_id, i+1);
	
	for(auto& th : threads) th.join();
	return 0;
}

参考

lock_guard - C++ Referencehttps://www.cplusplus.com/reference/mutex/lock_guard/mutex - C++ Referencehttps://www.cplusplus.com/reference/mutex/mutex/