C++ mutex 类及方法介绍

头文件介绍

Mutex 系列类(四种)

• std::mutex，最基本的 Mutex 类。
• std::recursive_mutex，递归 Mutex 类。
• std::time_mutex，定时 Mutex 类。
• std::recursive_timed_mutex，定时递归 Mutex 类。

Lock 类（两种）

• std::lock_guard，与 Mutex RAII 相关，方便线程对互斥量上锁。
• std::unique_lock，与 Mutex RAII 相关，方便线程对互斥量上锁，但提供了更好的上锁和解锁控制。

其他类型

• std::once_flag 标志位，与函数std::call_once 配合使用
• std::adopt_lock_t
• std::defer_lock_t
• std::try_to_lock_t

函数

• std::try_lock，尝试同时对多个互斥量上锁。
• std::lock，可以同时对多个互斥量上锁。
• std::scoped_lock RALL，可以同时对多个互斥量上锁并保证解锁。
• std::call_once，如果多个线程需要同时调用某个函数，call_once 可以保证多个线程对该函数只调用一次。

mutex

mutex 的全名为 mutual exclusion(互斥体)，其 object 用来协助采取独占且排他的方式控制“对资源（object或多个Object的组合）的并发访问”。

• 构造函数，std::mutex不允许拷贝构造，也不允许 move 拷贝，最初产生的 mutex 对象是处于 unlocked 状态的。

• lock()，调用线程将锁住该互斥量。线程调用该函数会发生下面 3 种情况：

  • (1). 如果该互斥量当前没有被锁住，则调用线程将该互斥量锁住，直到调用 unlock之前，该线程一直拥有该锁。
  • (2). 如果当前互斥量被其他线程锁住，则当前的调用线程被阻塞住。
  • (3). 如果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)。
• unlock()， 解锁，释放对互斥量的所有权。

• try\_lock()，尝试锁住互斥量，如果互斥量被其他线程占有，则当前线程也不会被阻塞。线程调用该函数也会出现下面 3 种情况，

  • (1). 如果当前互斥量没有被其他线程占有，则该线程锁住互斥量，直到该线程调用 unlock 释放互斥量。
  • (2). 如果当前互斥量被其他线程锁住，则当前调用线程返回 false，而并不会被阻塞掉。
  • (3). 如果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)。

下面给出一个与 std::mutex 的小例子：

#include   // std::cout
#include      // std::mutex
#include     // std::thread

volatile int counter(0);  // non-atomic counter
std::mutex mtx;           // locks access to counter

void attempt_10k_increases() {
    for (int i = 0; i < 10000; ++i) {
        if (mtx.try_lock()) {  // only increase if currently not locked:
            ++counter;
            mtx.unlock();
        }
    }
}

int main(int argc, const char* argv[]) {
    std::thread threads[10];
    for (int i = 0; i < 10; ++i)
        threads[i] = std::thread(attempt_10k_increases);

    for (auto& th : threads) th.join();
    std::cout << counter << " successful increases of the counter.\n";
    return 0;
}

std::recursive\_mutex 介绍

std::recursive_mutex 与 std::mutex 一样，也是一种可以被上锁的对象，但是和 std::mutex 不同的是，std::recursive_mutex 允许同一个线程对互斥量多次上锁（即递归上锁），来获得对互斥量对象的多层所有权，std::recursive_mutex 释放互斥量时需要调用与该锁层次深度相同次数的 unlock()，可理解为 lock() 次数和 unlock() 次数相同，除此之外，std::recursive_mutex 的特性和 std::mutex 大致相同。

recursive_mutex g_mutex;
void print123() {
    g_mutex.lock();
    g_mutex.lock();
    for (int i = 0; i < 3; i++) {
        this_thread::sleep_for(chrono::milliseconds(100));
        cout << i + 1;
    }
    g_mutex.unlock();
    g_mutex.unlock();
}

std::time\_mutex 介绍

std::time_mutex 比 std::mutex 多了两个成员函数，try_lock_for()，try_lock_until()。

try_lock_for 函数接受一个时间范围，表示在这一段时间范围之内线程如果没有获得锁则被阻塞住（与 std::mutex 的 try_lock() 不同，try_lock 如果被调用时没有获得锁则直接返回 false），如果在此期间其他线程释放了锁，则该线程可以获得对互斥量的锁，如果超时（即在指定时间内还是没有获得锁），则返回 false。

try_lock_until 函数则接受一个时间点作为参数，在指定时间点未到来之前线程如果没有获得锁则被阻塞住，如果在此期间其他线程释放了锁，则该线程可以获得对互斥量的锁，如果超时（即在指定时间内还是没有获得锁），则返回 false。

下面的小例子说明了 std::time_mutex 的用法：

#include     // std::chrono::milliseconds
#include   // std::cout
#include      // std::timed_mutex
#include     // std::thread

std::timed_mutex mtx;

void fireworks() {
    // waiting to get a lock: each thread prints "-" every 200ms:
    while (!mtx.try_lock_for(std::chrono::milliseconds(200))) {
        std::cout <<"-";
    }
    // got a lock! - wait for 1s, then this thread prints "*"
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    std::cout << "*\n";
    mtx.unlock();
}

int main() {
    std::thread threads[10];
    // spawn 10 threads:
    for (int i = 0; i < 10; ++i) threads[i] = std::thread(fireworks);

    for (auto& th : threads) th.join();

    return 0;
}

std::recursive\_timed\_mutex 介绍

和 std:recursive_mutex 与 std::mutex 的关系一样，std::recursive_timed_mutex 的特性也可以从 std::timed_mutex 推导出来，感兴趣的同鞋可以自行查阅。

std::lock\_guard 介绍

与 Mutex RAII 相关，方便线程对互斥量上锁和释放。例子

#include    // std::cout
#include       // std::mutex, std::lock_guard
#include   // std::logic_error
#include      // std::thread

std::mutex mtx;

void print_even(int x) {
    if (x % 2 == 0)
        std::cout << x << " is even\n";
    else
        throw(std::logic_error("not even"));
}

void print_thread_id(int id) {
    try {
        // 使用 lock_guard 锁定 mtx 可确保在销毁/异常时解锁：
        std::lock_guard lck(mtx);
        print_even(id);
    } catch (std::logic_error&) {
        std::cout << "[exception caught]\n";
    }
}

int main() {
    std::thread threads[10];
    // spawn 10 threads:
    for (int i = 0; i < 10; ++i)
        threads[i] = std::thread(print_thread_id, i + 1);

    for (auto& th : threads) th.join();

    return 0;
}

std::unique\_lock 介绍

与 Mutex RAII 相关，方便线程对互斥量上锁，但提供了更好的上锁和解锁控制。

类 unique_lock 是通用互斥包装器，允许延迟锁定、锁定的有时限尝试、递归锁定、所有权转移和与条件变量一同使用。

类 unique_lock 可移动，但不可复制——它满足可移动构造 (MoveConstructible) 和可移动赋值 (MoveAssignable) 但不满足可复制构造 (CopyConstructible) 或可复制赋值 (CopyAssignable) 。

类 unique\_lock 满足基本可锁定 (BasicLockable) 要求。若 Mutex 满足可锁定 (Lockable) 要求，则 unique\_lock 亦满足可锁定 (Lockable) 要求（例如：能用于 std::lock ） ；若 Mutex 满足可定时锁定 (TimedLockable) 要求，则 unique\_lock 亦满足可定时锁定 (TimedLockable) 要求。

功能与 std::lock_guard 类似

#include   // std::cout
#include      // std::mutex, std::unique_lock
#include     // std::thread

std::mutex mtx;  // mutex for critical section

void print_block(int n, char c) {
    // 独占std::cout:
    std::unique_lock lck(mtx);
    for (int i = 0; i < n; ++i) {
        std::cout << c;
    }
    std::cout << '\n';
}

int main() {
    std::thread th1(print_block, 50, '*');
    std::thread th2(print_block, 50, '$');

    th1.join();
    th2.join();

    return 0;
}

std::lock 介绍

template< class Lockable1, class Lockable2, class... LockableN >
void lock( Lockable1& lock1, Lockable2& lock2, LockableN&... lockn );

锁定给定的可锁定 (Lockable) 对象 lock1 、 lock2 、 ... 、 lockn ，用免死锁算法避免死锁。

以对 lock 、 try_lock 和 unlock 的未指定系列调用锁定对象。若调用 lock 或 unlock 导致异常，则在重抛前对任何已锁的对象调用 unlock 。

#include 
#include 
#include 
#include 
#include 
#include 
#include 

struct Employee {
    Employee(std::string id) : id(id) {}
    std::string id;
    std::vector lunch_partners;
    std::mutex m;  // 每一个对象都有一个锁
    std::string output() const {
        std::string ret = "Employee " + id + " has lunch partners: ";
        for (const auto &partner : lunch_partners) ret += partner + " ";
        return ret;
    }
};

void send_mail(Employee &, Employee &) {
    // 模拟耗时的发信操作
    std::this_thread::sleep_for(std::chrono::seconds(1));
}

void assign_lunch_partner(Employee &e1, Employee &e2) {
    static std::mutex io_mutex;
    {
        std::lock_guard lk(io_mutex);
        std::cout << e1.id << " and " << e2.id << " are waiting for locks"
                  << std::endl;
    }

    // 用 std::lock 获得二个锁，而不担心对 assign_lunch_partner
    // 的其他调用会死锁我们
    {
        std::lock(e1.m, e2.m);
        std::lock_guard lk1(e1.m, std::adopt_lock);// adopt_lock表示已经获取锁了，看上一行代码，这样的顺序是保证不死锁
        std::lock_guard lk2(e2.m, std::adopt_lock);
        // 等价代码（若需要 unique_locks ，例如对于条件变量）
        //        std::unique_lock lk1(e1.m, std::defer_lock); // defer_lock 表示延迟上锁
        //        std::unique_lock lk2(e2.m, std::defer_lock);
        //        std::lock(lk1, lk2);
        // C++17 中可用的较优解法
        //        std::scoped_lock lk(e1.m, e2.m);
        {
            std::lock_guard lk(io_mutex);
            std::cout << e1.id << " and " << e2.id << " got locks" << std::endl;
        }
        e1.lunch_partners.push_back(e2.id);
        e2.lunch_partners.push_back(e1.id);
    }
    send_mail(e1, e2);
    send_mail(e2, e1);
}

int main() {
    Employee alice("alice"), bob("bob"), christina("christina"), dave("dave");

    // 在平行线程指派，因为发邮件给用户告知午餐指派，会消耗长时间
    std::vector threads;
    threads.emplace_back(assign_lunch_partner, std::ref(alice), std::ref(bob));
    threads.emplace_back(assign_lunch_partner, std::ref(christina),
                         std::ref(bob));
    threads.emplace_back(assign_lunch_partner, std::ref(christina),
                         std::ref(alice));
    threads.emplace_back(assign_lunch_partner, std::ref(dave), std::ref(bob));

    for (auto &thread : threads) thread.join();
    std::cout << alice.output() << '\n'
              << bob.output() << '\n'
              << christina.output() << '\n'
              << dave.output() << '\n';
}

std::try\_lock

emplate< class Lockable1, class Lockable2, class... LockableN>
int try_lock( Lockable1& lock1, Lockable2& lock2, LockableN&... lockn);

尝试锁定每个给定的可锁定 (Lockable) 对象 lock1 、 lock2 、 ... 、 lockn ，通过以从头开始的顺序调用 try_lock 。

若调用 try_lock 失败，则不再进一步调用 try_lock ，并对任何已锁对象调用 unlock ，返回锁定失败对象的 0 底下标。

若调用 try_lock 抛出异常，则在重抛前对任何已锁对象调用 unlock 。

锁定成功的话返回 -1，锁定失败的话返回加锁对象的索引值。

#include 
#include 
#include 
#include 
#include 
#include 

void increment(int &counter, std::mutex &m, const char *desc) {
    for (int i = 0; i < 10; ++i) {
        std::unique_lock lock(m);
        ++counter;
        std::cout << desc << ": " << counter << '\n';
        lock.unlock();
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
}

int main() {
    int foo_count = 0;
    std::mutex foo_count_mutex;
    int bar_count = 0;
    std::mutex bar_count_mutex;
    int overall_count = 0;
    bool done = false;
    std::mutex done_mutex;

    std::thread increment_foo(increment, std::ref(foo_count),
                              std::ref(foo_count_mutex), "foo");
    std::thread increment_bar(increment, std::ref(bar_count),
                              std::ref(bar_count_mutex), "bar");

    std::thread update_overall([&]() {
        done_mutex.lock();
        while (!done) {
            done_mutex.unlock();
            int result = std::try_lock(foo_count_mutex, bar_count_mutex);
            if (result == -1) { // 对两个 mutex 都上了锁
                overall_count += foo_count + bar_count; // 读取两个值
                foo_count = 0;
                bar_count = 0;
                std::cout << "overall: " << overall_count << '\n';
                foo_count_mutex.unlock(); // 释放
                bar_count_mutex.unlock(); // 释放
            }
            std::this_thread::sleep_for(std::chrono::seconds(2));
            done_mutex.lock();
        }
        done_mutex.unlock();
    });

    increment_foo.join();
    increment_bar.join();
    done_mutex.lock();
    done = true;
    done_mutex.unlock();
    update_overall.join();

    std::cout << "Done processing\n"
              << "foo: " << foo_count << '\n'
              << "bar: " << bar_count << '\n'
              << "overall: " << overall_count << '\n';
}

std::scoped\_lock

类 scoped_lock 是提供便利 RAII 风格机制的互斥包装器，它在作用域块的存在期间占有一或多个互斥。

创建 scoped_lock 对象时，它试图取得给定互斥的所有权。控制离开创建 scoped_lock 对象的作用域时，析构 scoped_lock 并以逆序释放互斥。若给出数个互斥，则使用免死锁算法，如同以 std::lock 。

scoped_lock 类不可复制。

上一节中的代码节选，其中三种加锁效果相同：

{    
    // 使用 lock_guard, 这样的顺序是保证不死锁
    // std::lock(e1.m, e2.m);
    // std::lock_guard lk1(e1.m, std::adopt_lock);
    // std::lock_guard lk2(e2.m, std::adopt_lock);

    // 等价代码（若需要 unique_locks ，例如对于条件变量）
    //        std::unique_lock lk1(e1.m, std::defer_lock);
    //        std::unique_lock lk2(e2.m, std::defer_lock);
    //        std::lock(lk1, lk2);

    // C++17 中可用的较优解法：
    std::scoped_lock lk(e1.m, e2.m);
    {
        std::lock_guard lk(io_mutex);
        std::cout << e1.id << " and " << e2.id << " got locks" << std::endl;
    }
    e1.lunch_partners.push_back(e2.id);
    e2.lunch_partners.push_back(e1.id);
}

std::defer\_lock, std::try\_to\_lock, std::adopt\_lock

配合 std::lock_guard 、 std::unique_lock 及 std::shared_lock 指定锁定策略。

类型	效果
defer_lock_t	不获得互斥的所有权。表示该互斥元在构造时保持未被锁定，这个锁就可以在这之后通过lock来上锁，即延迟上锁。
try_to_lock_t	尝试获得互斥的所有权而不阻塞，相当于调用try\_lock。
adopt_lock_t	假设调用方线程已拥有互斥的所有权，此时不再上锁，只会转移所有权。

std::adopt_lock 表示已拿到锁：

std::mutex test5_mutex;
void test5() {
    test5_mutex.lock(); // 获取锁
        // 交给 lock_guard 来保管，保证锁的释放，ps：有点向go中的defer
    lock_guard lg(test5_mutex, std::adopt_lock); 
    
    cout << "hello test5" << endl;
}
void test5(int) {
    test5_mutex.lock(); // 获取所
    cout << "hello test5(int)" << endl;
    test5_mutex.unlock(); // 释放锁
}

int main() {
    thread t1([]() { test5(); });
    thread t2([]() { test5(2); });

    t1.join();
    t2.join();
    return 0;
}

std::call\_once

template< class Callable, class... Args >
void call_once( std::once_flag& flag, Callable&& f, Args&&... args );

准确执行一次可调用 (Callable) 对象 f ，即使同时从多个线程调用。

细节为：

• 若在调用 call_once 的时刻， flag 指示已经调用了 f ，则 call_once 立即返回（称这种对 call_once 的调用为\_消极\_）。
• 否则， call_once 以参数 std​::​forward(args)... 调用 ​std​::​forward(f) （如同用 std::invoke ）。不同于 std::thread 构造函数或 std::async ，不移动或复制参数，因为不需要转移它们到另一执行线程（称这种对 call_once 的调用为\_积极\_）。
• 若该调用抛异常，则传播异常给 call_once 的调用方，并且不翻转 flag ，以令其他调用将得到尝试（这种对 call_once 的调用被称为\_异常\_）。
• 若该调用正常返回（这种对 call_once 的调用被称为\_返回\_），则翻转 flag ，并保证以同一 flag 对 call_once 的其他调用为\_消极\_。

同一 flag 上的所有\_积极\_调用组成单独全序，它们由零或多个\_异常\_调用后随一个\_返回\_调用组成。该顺序中，每个\_积极\_调用的结尾同步于下个\_积极\_调用。

从\_返回\_调用的返回同步于同一 flag 上的所有\_消极\_调用：这表示保证所有对 call_once 的同时调用都观察到\_积极\_调用所做的任何副效应，而无需额外同步。

#include 
#include 
#include 

std::once_flag flag1, flag2;

void simple_do_once() {
    std::call_once(flag1,
                   []() { std::cout << "Simple example: called once\n"; });
}

void may_throw_function(bool do_throw) {
    if (do_throw) {
        // 这会出现多于一次, 因为发生异常后会重置 flag
        std::cout << "throw: call_once will retry\n";  
        throw std::exception();
    }
    std::cout
        << "Didn't throw, call_once will not attempt again\n";  // 保证一次
}

void do_once(bool do_throw) {
    try {
        std::call_once(flag2, may_throw_function, do_throw);
    } catch (...) {
    }
}

int main() {
    std::thread st1(simple_do_once);
    std::thread st2(simple_do_once);
    std::thread st3(simple_do_once);
    std::thread st4(simple_do_once);
    st1.join();
    st2.join();
    st3.join();
    st4.join();

    std::thread t1(do_once, true);
    std::thread t2(do_once, true);
    std::thread t3(do_once, false);
    std::thread t4(do_once, true);
    t1.join();
    t2.join();
    t3.join();
    t4.join();
}

很多代码示例来自 C++ 参考手册