C++互斥锁

C++11提供了四种互斥锁：

1. mutex：互斥锁。
2. timed_mutex：带超时机制的互斥锁。
3. recursive_mutex：递归互斥锁。
4. recursive_timed_mutex：带超时机制的递归互斥锁。

包含头文件：#include <mutex>

一、mutex类

1）加锁lock()

互斥锁有锁定和未锁定两种状态。

如果互斥锁是未锁定状态，调用lock()成员函数的线程会得到互斥锁的所有权，并将其上锁。

如果互斥锁是锁定状态，调用lock()成员函数的线程就会阻塞等待，直到互斥锁变成未锁定状态。

2）解锁unlock()

只有持有锁的线程才能解锁。

3）尝试加锁try_lock()

如果互斥锁是未锁定状态，则加锁成功，函数返回true。

如果互斥锁是锁定状态，则加锁失败，函数立即返回false。（线程不会阻塞等待）

二、timed_mutex类

带超时机制的互斥锁。

增加了两个成员函数：

bool try_lock_for(时间长度);

bool try_lock_until(时间点);

三、recursive_mutex类

递归互斥锁。

允许同一线程多次获得互斥锁，可以解决同一线程多次加锁造成的死锁问题。

四、lock_guard类

lock_guard是模板类，可以简化互斥锁的使用，也更安全。

lock_guard的定义如下：

template<class Mutex>
class lock_guard
{
    explicit lock_guard(Mutex& mtx);
}

lock_guard在构造函数中加锁，在析构函数中解锁。

lock_guard采用了RAII思想（在类构造函数中分配资源，在析构函数中释放资源，保证资源在离开作用域时自动释放）。

演示：

#include <iostream>
#include <thread>                // 线程类头文件。
#include <mutex>                // 互斥锁类的头文件。
using namespace std;
//互斥锁 包含头文件：#include <mutex>
// mutex：互斥锁。
// timed_mutex：带超时机制的互斥锁。
// recursive_mutex：递归互斥锁。
// recursive_timed_mutex：带超时机制的递归互斥锁。
// 
// lock_guard是模板类，可以简化互斥锁的使用，也更安全。
// 
//

mutex mtx;		//创建互斥锁对象，保护共享资源

// 普通函数。
void func(int num, const string& str) {
	for (int ii = 1; ii <= 5; ii++)
	{
		mtx.lock();      // 申请加锁。
		cout << "第" << ii << "次表白：亲爱的" << num << "号，" << str << endl;
		mtx.unlock();  // 解锁。
		this_thread::sleep_for(chrono::seconds(1));     // 休眠1秒。
	}
}

int main()
{
	// 用普通函数创建线程。
	thread t1(func, 1, "我是月月鸟");
	thread t2(func, 2, "我是光军");

	t1.join();         // 回收线程t1的资源。
	t2.join();         // 回收线程t2的资源。

}

不使用互斥锁的情况：

两个线程共享全局对象cout，争相输出，混乱无序。