• try_lock_for(duration)：尝试在指定的时间内获取锁，如果超时则返回 false。

• try_lock_until(time_point)：尝试在指定的时间点之前获取锁，如果超时则返回 false。

#include <iostream>
#include <thread>
#include <mutex>
#include <chrono>
using namespace std;
timed_mutex mtx;

void func(int id) {
    chrono::seconds timeout(3); // 设置超时时间为3秒
    if (mtx.try_lock_for(timeout)) {
        cout << "线程 " << id << " 成功获取锁，执行临界区代码..." << endl;
        this_thread::sleep_for(chrono::seconds(5)); // 模拟工作负载
        mtx.unlock();
    }
    else {
        cout << "线程 " << id << " 超时未能获取锁，继续执行其他任务..." << endl;
    }
}

int main() {
    thread t1(func, 1);
    thread t2(func, 2);
    t1.join();
    t2.join();

    return 0;
}

recursive_mutex

1. 调⽤⽅线程在从它成功调⽤ lock 或 try_lock 开始的时期⾥占有 recursive_mutex。此时期之内，线程可以进⾏对 lock 或 try_lock 的附加调⽤。所有权的时期在线程进⾏匹配次数的 unlock 调⽤时结束。
2. 线程占有 recursive_mutex 时，若其他所有线程试图要求 recursive_mutex 的所有权，则它们将阻塞（对于调⽤ lock）或收到 false 返回值（对于调⽤ try_lock）。

#include <iostream>
#include <mutex>
#include <thread>
using namespace std;
recursive_mutex rec_mutex;

void recursiveFunction(int count) {
    if (count <= 0) return;
    rec_mutex.lock();
    cout << "Lock acquired. Count: " << count << endl;
    // 递归调用
    recursiveFunction(count - 1);

    rec_mutex.unlock();
    cout << "Lock released. Count: " << count << endl;
}

int main() {
    thread t(recursiveFunction, 3);
    t.join();
    return 0;
}

lock_guard

std::lock_guard 是 C++ 标准库中用于管理互斥锁的 RAII（Resource Acquisition Is Initialization，资源获取即初始化）工具。它通过构造函数自动获取互斥锁，并在析构函数中自动释放锁，从而确保互斥锁的正确管理，避免因忘记解锁而导致的死锁问题。

主要特性

1. 自动管理锁：通过构造函数获取锁，析构函数释放锁,无需手动调用 lock() 和 unlock()。

2. 防止死锁：确保即使在异常情况下也能正确释放锁。

3. 不可移动和复制：std::lock_guard 不支持拷贝或移动构造，确保锁的唯一性。

构造函数

explicit lock_guard(MutexType& mutex, std::adopt_lock_t tag = std::defer_lock);

• MutexType& mutex：要管理的互斥锁对象，如mutex，timed_mutex，recersive_mutex。

• std::adopt_lock_t tag：可选参数，表示当前线程已经持有锁，默认值是 std::defer_lock，表示 lock_guard 会在构造时自动尝试加锁。如果传入 std::adopt_lock，则表示当前线程已经通过其他方式（例如 std::lock 或手动调用 lock()）持有锁，lock_guard 不会再次尝试加锁，而是直接接管锁的管理。

#include <iostream>
#include <thread>
#include <mutex>
using namespace std;
mutex mtx;
void print_block(int n, char c) {
    lock_guard<mutex> lock(mtx);  // 默认加锁，无需手动解锁
    for (int i = 0; i < n; ++i) {
        cout << c;
    }
    cout << '\n';
}

int main() {
    thread t1(print_block, 50, '*');
    thread t2(print_block, 50, '$');
    t1.join();
    t2.join();
    return 0;
}

unique_lock

构造函数

template <typename Mutex>
unique_lock() noexcept;  // 默认构造，不绑定任何锁

template <typename Mutex>
explicit unique_lock(Mutex& m, std::defer_lock_t);  // 延迟加锁

template <typename Mutex>
unique_lock(Mutex& m, std::try_to_lock_t);  // 尝试加锁，失败时不阻塞

template <typename Mutex>
unique_lock(Mutex& m, std::adopt_lock_t);  // 假设已持有锁，不加锁

template <typename Mutex>
unique_lock(Mutex& m);  // 默认加锁

template <typename Mutex>
unique_lock(Mutex& m, std::unique_lock<Mutex>&& other);  // 移动构造

主要成员函数

1. lock()：尝试加锁，如果锁已被占用则阻塞。

2. try_lock()：尝试加锁，如果锁已被占用则立即返回 false。

3. unlock()：释放锁。

4. owns_lock()：检查是否持有锁。

5. mutex()：获取绑定的互斥锁对象。

6. release()：释放锁的所有权，但不释放锁本身。

7. swap()：交换两个 std::unique_lock 的状态。

lock和try_lock

#include <iostream>
#include <thread>
#include <mutex>
using namespace std;
mutex mtx1;
mutex mtx2;
void worker() {
    lock(mtx1, mtx2);  // 同时锁定两个锁
    unique_lock<mutex> lock1(mtx1, std::adopt_lock);  // 需要创建 unique_lock 自动释放锁
    unique_lock<mutex> lock2(mtx2, std::adopt_lock);

    cout << "线程进入临界区..." << endl;
    this_thread::sleep_for(chrono::seconds(1));  // 模拟工作负载
    cout << "线程退出临界区..." << endl;
}

int main() {
    thread t1(worker);
    thread t2(worker);
    t1.join();
    t2.join();
    return 0;
}

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

#include <iostream>
#include <thread>
#include <mutex>
using namespace std;

std::once_flag flag;
void init(int id) {
    cout << "Initialization function called once." << endl;
    cout << "thread " << id << " is running." << endl;
}

void worker(int id) {
    call_once(flag, init,id);  // 确保 init 只被调用一次
}

int main() {
    thread t1(worker, 1);
    thread t2(worker, 2);
    thread t3(worker, 3);
    t1.join();
    t2.join();
    t3.join();
    return 0;
}