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_