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

std::mutex mtx; // 全局互斥锁

int shared_resource = 0;

void increment() {

    for (int i = 0; i < 10000; ++i) {

        mtx.lock(); // 锁定互斥锁

        ++shared_resource;

        mtx.unlock(); // 解锁互斥锁

    }

}

int main() {

    std::thread t1(increment);

    std::thread t2(increment);

    t1.join();

    t2.join();

    std::cout << "Final value of shared_resource: " << shared_resource << std::endl;

    return 0;

}

Final value of shared_resource: 20000

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


std::recursive_mutex rmtx; // 创建一个递归 mutex 对象

int shared_resource = 0; // 共享资源

// 递归函数

void recursive_increment(int count) {

    if (count <= 0) return;

    std::lock_guard<std::recursive_mutex> lock(rmtx); // 上锁，确保线程安全

    ++shared_resource;

    std::cout << "Incremented shared_resource to " << shared_resource << " (count = " << count << ")" << std::endl;

    // 递归调用

    recursive_increment(count - 1);

}

int main() {

    std::thread t1(recursive_increment, 3); // 线程 t1 执行 recursive_increment(3)
    std::thread t2(recursive_increment, 3); // 线程 t2 执行 recursive_increment(3)

    t1.join(); // 等待线程 t1 完成
    t2.join(); // 等待线程 t2 完成

    std::cout << "Final value of shared_resource: " << shared_resource << std::endl;

    return 0;

}

Incremented shared_resource to 1 (count = 3)
Incremented shared_resource to 2 (count = 2)
Incremented shared_resource to 3 (count = 1)
Incremented shared_resource to 4 (count = 0)
Incremented shared_resource to 5 (count = 3)
Incremented shared_resource to 6 (count = 2)
Incremented shared_resource to 7 (count = 1)
Incremented shared_resource to 8 (count = 0)
Final value of shared_resource: 8

#include <mutex>

std::mutex mtx;

void thread_function() {
    std::lock_guard<std::mutex> lock(mtx);
    // 访问共享资源
}

#include <mutex>

std::recursive_mutex rmtx;

void recursive_function(int count) {
    if (count <= 0) return;
    std::lock_guard<std::recursive_mutex> lock(rmtx);
    // 递归调用
    recursive_function(count - 1);
}

#include <mutex>
#include <chrono>

std::timed_mutex tm;

void try_lock_for_example() {
    if (tm.try_lock_for(std::chrono::seconds(1))) {
        // 成功获得锁
        tm.unlock();
    } else {
        // 锁获取失败
    }
}

#include <mutex>
#include <chrono>

std::recursive_timed_mutex rtm;

void recursive_timed_function(int count) {
    if (count <= 0) return;
    if (rtm.try_lock_for(std::chrono::seconds(1))) {
        // 成功获得锁
        recursive_timed_function(count - 1);
        rtm.unlock();
    } else {
        // 锁获取失败
    }
}

#include <mutex>

std::mutex mtx;

void function() {
    std::lock_guard<std::mutex> lock(mtx);
    // 访问共享资源
}

#include <mutex>
#include <chrono>

std::mutex mtx;

void function() {
    std::unique_lock<std::mutex> lock(mtx);
    // 访问共享资源
  
    // 可以手动释放锁
    lock.unlock();
  
    // 可以重新获得锁
    lock.lock();

   // 可以进行定时锁定
    if (lock.try_lock_for(std::chrono::seconds(1))) {
        // 成功获得锁
    }
}

std::mutex mtx;
std::unique_lock<std::mutex> lock(mtx, std::adopt_lock);

std::mutex mtx;
std::unique_lock<std::mutex> lock(mtx, std::defer_lock);
// 可以在之后的某个时刻调用 lock.lock()

std::mutex mtx1, mtx2;
std::unique_lock<std::mutex> lock1(mtx1, std::try_to_lock);
std::unique_lock<std::mutex> lock2(mtx2, std::try_to_lock);

if (lock1 && lock2) {
    // 成功获得两个锁
}