c++11多线程：lock_guard 与 unique_lock

lock_guard

lock_guard 是 C++ 标准库中的一种互斥量封装类，用于保护共享数据，防止多个线程同时访问同一资源而导致的数据竞争问题。
特点：

• 当构造函数被调用时，该互斥量会被自动锁定。

• 当析构函数被调用时，该互斥量会被自动解锁。

• std::lock_guard 对象不能复制或移动，因此它只能在局部作用域中使用。

#include <iostream>
#include <thread>
#include <mutex>
using namespace std;
int shared_data = 0;
mutex mtx;
void func()
{
	for (int i=0;i<10000;i++)
	{
	//构造的时候 就对互斥变量加锁了，超出作用域的时候会自动释放，通过析构函数来解锁
		lock_guard<mutex> lg(mtx);
		//使用这个重装函数的时候，表示这个互斥量已经被加锁了，不需要被加锁，所以传入一个常量
		//lock_guard<mutex> lg(mtx,adopt_lock);
		shared_data++;
	}
}
int main()
{
	thread t1(func);
	thread t2(func);
	t1.join();
	t2.join();
	cout << "shared_data = " << shared_data;
	return 0;
}

执行结果：

shared_data = 20000

unique_lock

std::unique_lock 是 C++ 标准库中提供的一个互斥量封装类，用于在多线程程序中对互斥量进行加锁和解锁操作。
特点：可以对互斥量进行更加灵活的管理，包括延迟加锁、条件变量、超时等。

2.1 成员函数：

• lock()：尝试对互斥量进行加锁操作，如果当前互斥量已经被其他线程持有，则当前线程会被阻塞，直到互斥量被成功加锁。

• try_lock()：尝试对互斥量进行加锁操作，如果当前互斥量已经被其他线程持有，则函数立即返回 false，否则返回 true。

• try_lock_for(const std::chrono::duration<Rep, Period>& rel_time)：尝试对互斥量进行加锁操作，如果当前互斥量已经被其他线程持有，则当前线程会被阻塞，直到互斥量被成功加锁，或者超过了指定的时间。

• try_lock_until(const std::chrono::time_point<Clock, Duration>& abs_time)：尝试对互斥量进行加锁操作，如果当前互斥量已经被其他线程持有，则当前线程会被阻塞，直到互斥量被成功加锁，或者超过了指定的时间点。

• unlock()：对互斥量进行解锁操作。

代码示例：

/*----------------------例一---------------------------------*/
#include <iostream>
#include <thread>
#include <mutex>
using namespace std;
int shared_data = 0;
mutex mtx;
void func()
{
	for (int i=0;i<10000;i++)
	{
		unique_lock<mutex> lg(mtx,defer_lock);//构造的时候 不加锁
		shared_data++;
	}
}
int main()
{
	thread t1(func);
	thread t2(func);
	t1.join();
	t2.join();
	cout << "shared_data = " << shared_data;

	return 0;
}

/*----------------------例二---------------------------------*/
#include <iostream>
#include <thread>
#include <mutex>
using namespace std;
int shared_data = 0;
timed_mutex mtx;
void func()
{
	for (int i=0;i<2;i++)
	{
		unique_lock<timed_mutex> lg(mtx,defer_lock);//构造的时候 不加锁
		//timed_mutex支持try_lock_for 所以使用timed_mutex
		//尝试加锁，如果被阻塞，阻塞2s自动返回，在2s内拿到资源就继续执行
		if (lg.try_lock_for(chrono::seconds(2)))
		{
			this_thread::sleep_for(chrono::seconds(1));
			shared_data++;
		}
	}
}
int main()
{
	thread t1(func);
	thread t2(func);
	t1.join();
	t2.join();
	cout << "shared_data = " << shared_data;
	return 0;
}

2.2 构造函数重载

• unique_lock() noexcept = default：默认构造函数，创建一个未关联任何互斥量的 std::unique_lock 对象。

• explicit unique_lock(mutex_type& m)：构造函数，使用给定的互斥量 m 进行初始化，并对该互斥量进行加锁操作。

• unique_lock(mutex_type& m, defer_lock_t) noexcept：构造函数，使用给定的互斥量 m 进行初始化，但不对该互斥量进行加锁操作。

• unique_lock(mutex_type& m, try_to_lock_t) noexcept：构造函数，使用给定的互斥量 m 进行初始化，并尝试对该互斥量进行加锁操作。如果加锁失败，则创建的 std::unique_lock 对象不与任何互斥量关联。

• unique_lock(mutex_type& m, adopt_lock_t) noexcept：构造函数，使用给定的互斥量 m 进行初始化，并假设该互斥量已经被当前线程成功加锁。