1、使用互斥量
在C++中,我们通过构造std::mutex
的实例来创建互斥量,调用成员函数lock()
对其加锁,调用unlock()
解锁。但通常更推荐的做法是使用标准库提供的类模板std::lock_guard<>
,它针对互斥量实现了RAII手法:在构造时给互斥量加锁,析构时解锁。两个类都在头文件<mutex>
里声明。
std::list<int> some_list;
std::mutex some_mutex;
void add_to_list(int value)
{
//C++17引入了类模板参数推导的新特性,所以下面语句也可以简化成:std::lock_guard guard(some_mutex);
std::lock_guard<std::mutex> guard(some_mutex);
some_list.push_back(value);
}
bool list_contains(int value)
{
std::lock_guard<std::mutex> guard(some_mutex);
return std::find(some_list.begin(), some_list.end(), value) != some_list.end();
}
2、防范死锁
假设有两个线程,都需要同时锁住两个互斥量才能进行某种操作,但它们分别只锁住了一个互斥量,都等着再给另一个互斥量加锁,这就构成了死锁。标准库提供了std::lock
函数来解决死锁的问题,它可以同时锁住多个互斥量。
class some_big_object {};
void swap(some_big_object& lhs, some_big_object& rhs) {}
class X
{
private:
some_big_object some_detail;
mutable std::mutex m;
public:
X(const some_big_object& sd) :some_detail(sd) {}
friend void swap(X& lhs, X& rhs)
{
if (&lhs == &rhs) { return; }
std::lock(lhs.m, rhs.m);
std::lock_guard<std::mutex> lock_a(lhs.m, std::adopt_lock);
std::lock_guard<std::mutex> lock_b(rhs.m, std::adopt_lock);
swap(lhs.some_detail, rhs.some_detail);
}
};
本例中必须要判断两个参数是否指向不同的实例,因为如果已经在某个std::mutex
对象上加锁,那么再次试图加锁将导致未定义的行为。构造std::lock_guard
对象时,额外参数std::adopt_lock
指明互斥量已被锁住,std::lock_guard
实例应当据此接收锁的归属权,不得在构造函数内试图另行加锁。
针对上述场景,C++17还提供了新的RAII模板类std::scoped_lock<>
,它和std::lock_guard<>
完全等价,只不过前者是可变参数模板,接收各种互斥量型别作为模板参数列表,还以多个互斥量对象作为构造函数参数列表。下列代码中,传入构造函数的两个互斥量都被加锁,机制与std::lock()函数相同,因此,当构造函数完成时它们都被锁定,而后在析构函数内一起被解锁。
void swap(X& lhs, X& rhs)
{
if (&lhs == &rhs) { return; }
//这里使用了C++17的类模板参数推导特性,下面的语句完全等价于std::scoped_lock<std::mutex, std::mutex> guard(lhs.m, rhs.m);
std::scoped_lock guard(lhs.m, rhs.m);
swap(lhs.some_detail, rhs.some_detail);
}
标准库也提供了std::unique_lock<>
模板,它与std::lock_guard<>
一样,也是一个以互斥量作为参数的类模板,并且以RAII手法管理锁,不过它更灵活一些(代价是略微损失性能)。std::unique_lock<>
的构造函数接收第二个参数,我们可以传入std::adopt_lock
以指明std::unique_lock
对象管理互斥量上的锁,也可以传入std::defer_lock
使互斥量在完成构造时处于无锁状态,等以后有需要时再加锁。
void swap(X& lhs, X& rhs)
{
if (&lhs == &rhs) { return; }
std::unique_lock<std::mutex> lock_a(lhs.m, std::defer_lock);
std::unique_lock<std::mutex> lock_b(rhs.m, std::defer_lock);
std::lock(lock_a, lock_b);
swap(lhs.some_detail, rhs.some_detail);
}
std::unique_lock
类十分灵活,它具有成员函数lock()
、try_lock()
、unlock()
,这与互斥量的基本成员函数一致,所以该类可以结合泛型函数来使用,例如std::lock()
。std::unique_lock
的实例可以在销毁前通过成员函数unlock()
解锁,这意味着如果执行流程的任何特定分支没有必要继续持有锁,那我们就可以提前解锁,这在有些情况下可能有助于提升程序性能。
锁的归属权可以在多个std::unique_lock
实例之间转移,比如一个函数锁定互斥量,然后把锁的归属权转移给函数的调用者,好让它在同一个锁的保护下执行其它操作,例如:
std::unique_lock<std::mutex> get_lock()
{
extern std::mutex some_mutex;
std::unique_lock<std::mutex> lk(some_mutex);
prepare_data();
return lk;
}
void process_data()
{
std::unique_lock<std::mutex> lk(get_lock());
do_something();
}
3、保护共享数据的其它工具
3.1、保护共享数据的初始化
假设共享数据只在初始化过程中需要保护,此后无需再进行显式的同步操作,那么可以使用std::once_flag
类和std::call_once
函数来处理这种情况,它们可以保证初始化操作只会执行一次。std::once_flag
的实例既不可复制也不可移动,这与std::mutex
类似。
std::shared_ptr<some_