C++ 中的 std::timed_mutex 和 std::recursive_timed_mutex

1、背景

在多线程编程中，互斥锁（Mutex）是用于保护共享资源的重要工具。C++ 标准库提供了多种互斥锁类型，其中 std::timed_mutex 和 std::recursive_timed_mutex 是两种支持超时功能的互斥锁。在阅读FastDDS源码时，发现了这两种类型，以前没有使用过，顺便补盲记录下。

2、std::timed_mutex

std::timed_mutex 是 C++11 引入的一种互斥锁类型，它在 std::mutex 的基础上增加了超时功能。通过 std::timed_mutex，线程可以尝试获取锁，并在指定的时间内等待锁的释放。如果超时仍未获取到锁，线程可以执行其他操作，而不是一直阻塞。

2.1、std::timed_mutex特性

• 支持超时，提供了 try_lock_for() 和 try_lock_until() 方法，允许线程在指定的时间内尝试获取锁。
• 非递归锁，同一个线程不能重复获取 std::timed_mutex，否则会导致死锁。
• 轻量级，与 std::mutex 相比，std::timed_mutex 的性能开销略高，但提供了更多的灵活性。

2.2、std::timed_mutex常用方法

• lock()：尝试获取锁，如果锁已被其他线程持有，则阻塞当前线程。
• unlock()：释放锁。
• try_lock()：尝试获取锁，如果锁已被其他线程持有，则立即返回 false。
• try_lock_for()：在指定的时间内尝试获取锁，如果超时仍未获取到锁，则返回 false。
• try_lock_until()：在指定的时间点之前尝试获取锁，如果超时仍未获取到锁，则返回 false。

2.3、示例代码

#include <iostream>
#include <thread>
#include <mutex>
#include <chrono>

std::timed_mutex timed_mtx;

void task(int id) {
    auto timeout = std::chrono::milliseconds(100); // 超时时间为 100ms
    if (timed_mtx.try_lock_for(timeout)) {
        std::cout << "Thread " << id << " acquired the lock." << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(200)); // 模拟任务执行
        timed_mtx.unlock();
    } else {
        std::cout << "Thread " << id << " failed to acquire the lock." << std::endl;
    }
}

int main() {
    std::thread t1(task, 1);
    std::thread t2(task, 2);

    t1.join();
    t2.join();

    return 0;
}
/*
输出结构:
Thread 1 acquired the lock.
Thread 2 failed to acquire the lock.
*/

3、std::recursive_timed_mutex

std::recursive_timed_mutex 是 std::timed_mutex 的递归版本。它允许同一个线程多次获取锁，而不会导致死锁。每次获取锁后，必须释放相同次数的锁。

3.1、std::timed_mutex特性

• 支持递归，同一个线程可以多次获取 std::recursive_timed_mutex，但必须释放相同次数的锁。
• 支持超时，提供了 try_lock_for() 和 try_lock_until() 方法，允许线程在指定的时间内尝试获取锁。
• 性能开销，由于支持递归，std::recursive_timed_mutex 的性能开销比 std::timed_mutex 更高。

3.2、std::timed_mutex常用方法

• lock()：尝试获取锁，如果锁已被其他线程持有，则阻塞当前线程。
• unlock()：释放锁。
• try_lock()：尝试获取锁，如果锁已被其他线程持有，则立即返回 false。
• try_lock_for()：在指定的时间内尝试获取锁，如果超时仍未获取到锁，则返回 false。
• try_lock_until()：在指定的时间点之前尝试获取锁，如果超时仍未获取到锁，则返回 false。

3.3、示例代码

#include <iostream>
#include <thread>
#include <mutex>
#include <chrono>

std::recursive_timed_mutex recursive_timed_mtx;

void recursive_task(int id, int depth) {
    auto timeout = std::chrono::milliseconds(100); // 超时时间为 100ms
    if (recursive_timed_mtx.try_lock_for(timeout)) {
        std::cout << "Thread " << id << " acquired the lock at depth " << depth << "." << std::endl;
        if (depth > 0) {
            recursive_task(id, depth - 1); // 递归调用
        }
        recursive_timed_mtx.unlock();
    } else {
        std::cout << "Thread " << id << " failed to acquire the lock at depth " << depth << "." << std::endl;
    }
}

int main() {
    std::thread t1(recursive_task, 1, 3);
    std::thread t2(recursive_task, 2, 3);

    t1.join();
    t2.join();

    return 0;
}
/*
输出结果如下:
Thread 1 acquired the lock at depth 3.
Thread 1 acquired the lock at depth 2.
Thread 1 acquired the lock at depth 1.
Thread 1 acquired the lock at depth 0.
Thread 2 failed to acquire the lock at depth 3.
*/