C++多线程编程之mutex

参考’www.cplusplus.com’

互斥量、互斥锁，用于锁住临界区，防止多个线程同时处于临界区中对临界资源进行操作。
C++中的 mutex是一个类，可创建可锁对象。 mutex对象提供专属所有权，且不支持递归。所谓专属所有权是指，对已经被其他线程占有的 mutex对象，当前线程不能再进行锁操作，否则会被阻塞。

构造函数

constexpr mutex() noexcept;
mutex (const mutex&) = delete;

mutex类只能使用默认构造函数，新构造的对象处于解锁状态（unlock）。
mutex类不支持拷贝构造函数、移动构造函数、赋值操作。

析构函数

~mutex();

使用析构函数销毁mutex对象时，对象必须处于解锁状态（unlock），否则会造成未定义行为。

成员函数

mutex::lock

lock函数锁住mutex，即上锁。

• 若mutex现在没有被其他线程锁住，则调用线程获得锁，直至线程调用unlock释放锁时，其他线程才能获得锁。
• 若mutex现在被其他线程锁住了，则调用线程将被阻塞，直到获得锁的线程释放锁。
• 若mutex被同一个线程获得两次，即该线程上锁后，又进行了一次上锁，这将导致死锁。（recursive_mutex即递归锁，允许同一个线程多次获得锁）

lock函数还有非成员函数版本，非成员函数lock允许同时锁住多个mutex，避免了多个线程以不同的顺序lock/unlock单个mutex对象时可能造成的死锁。

mutex::try_lock

顾名思义，尝试上锁，但不会阻塞该线程。若锁已被其他线程获得，则返回false；否则，上锁，返回true。
同样地，同一个线程获得该锁后，又执行try_lock操作，也会造成死锁。

该函数有个缺点：可能造成虚假的上锁失败，即锁未被其他线程获得，但尝试获得锁时还是失败了。这个问题可以通过重复调用try_lock解决。

mutex::unlock

void unlock();

该函数用于解锁mutex对象，释放所有权。解锁后，其他被阻塞的线程将尝试获得锁，这些阻塞线程中某一个线程将获得锁并继续运行。
如果mutex没有被锁住，而线程仍调用unlock去解锁，将会造成未定义行为。

mutex::native_handle

native_handle_type native_handle();

获得原始句柄。该成员函数需要库函数支持，且只存在于mutex类中。
该函数可返回用于访问与mutex对象相关的具体实现信息的值。

实例

1、子线程和主线程交替打印一段信息，重复5次。使用lock和unlock。

#include <iostream>
#include <thread>
#include <mutex>
std::mutex mt;//默认构造函数，新构造的对象处于解锁状态
void f(std::string str) {
	//重复5次
	for (int i = 0; i < 5; i++) {
		mt.lock();//上锁
		//中间这一段代码就是临界区，即访问临界资源的代码
		std::cout << str << " 第" << i << "次：" << "线程" << std::this_thread::get_id() << "获得锁" << std::endl;
		mt.unlock();//解锁
		std::this_thread::sleep_for(std::chrono::seconds(1));//当前线程休眠1秒，好让其他线程获得锁
	}
}
int main() {
	std::thread th1(f, "子线程");
	std::this_thread::sleep_for(std::chrono::milliseconds(100));//主线程先睡眠100毫秒，子线程先获得锁
	f("主线程");
	th1.join();//等待子线程运行结束
	return 0;
}

运行结果：

2、 使用try_lock，验证该函数未获得锁不会阻塞线程

#include <iostream>
#include <thread>
#include <mutex>
std::mutex mt;//默认构造函数，新构造的对象处于解锁状态
void f(std::string str) {
	std::this_thread::sleep_for(std::chrono::milliseconds(100));//当前线程先睡眠100毫秒，让主线程获得锁
	//如果try_lock会阻塞线程，则循环中的内容不会被执行
	while (mt.try_lock() == false) {
		std::cout << "我 " << str << "还未获得锁！" << std::endl;
		std::this_thread::sleep_for(std::chrono::milliseconds(500));//睡眠500毫秒，避免一直打印
	}
	//执行到这里，说明子线程获得了锁
	std::cout << "我 " << str << "终于获得锁！" << std::endl;
	mt.unlock();//子线程释放锁
}
int main() {
	mt.lock();//主线程先上锁，再创建子线程
	std::thread th1(f, "子线程");
	std::this_thread::sleep_for(std::chrono::seconds(5));//主线程先睡眠5秒，子线程会因得不到锁一直输出信息
	mt.unlock();//主线程释放锁
	th1.join();
	return 0;
}

运行结果：

3、同一个线程获得锁后，再上锁，验证不能让同一个线程连续两次获得同一个锁

#include <iostream>
#include <thread>
#include <mutex>
std::mutex mt;//默认构造函数，新构造的对象处于解锁状态
int main() {
	mt.lock();//第一次上锁
	mt.lock();//第二次上锁
	std::cout << "上面连续执行两次上锁操作，终于执行到这里了" << std::endl;
	return 0;
}

运行结果：
提示system_error。

4、对未上锁的mutex对象执行unlock操作，验证不能对未上锁的锁进行解锁操作

#include <iostream>
#include <thread>
#include <mutex>
std::mutex mt;//默认构造函数，新构造的对象处于解锁状态
int main() {
	mt.lock();
	std::cout << "上面连续执行两次上锁操作，终于执行到这里了" << std::endl;
	mt.unlock();//解锁后，mt处于未上锁状态
	mt.unlock();//对未上锁的mt上锁
	return 0;
}

运行结果：
输出信息后，提示