当前位置：首页 > news >正文

C++标准库中各种互斥锁的用法 mutex

news 2025/7/12 20:11:11

示例

仅供参考学习

#include <mutex>
#include <shared_mutex>
#include <thread>
#include <chrono>
#include <iostream>
#include <vector>// ============================================
// 1. std::mutex - 基本互斥锁
// ============================================
void basic_mutex_example() {std::mutex mtx;int counter = 0;// 1.1 使用 lock_guard - 最简单的RAII方式{std::lock_guard<std::mutex> lock(mtx);counter++;// 作用域结束时自动解锁}// 1.2 手动加锁解锁（不推荐，容易忘记解锁）mtx.lock();counter++;mtx.unlock();// 1.3 尝试加锁if (mtx.try_lock()) {counter++;mtx.unlock();}
}// ============================================
// 2. std::unique_lock - 灵活控制锁
// ============================================
void unique_lock_example() {std::mutex mtx;// 2.1 基本使用（类似lock_guard）{std::unique_lock<std::mutex> lock(mtx);// 临界区代码} // 自动解锁// 2.2 延迟加锁{std::unique_lock<std::mutex> lock(mtx, std::defer_lock);// 此时还没有加锁// 做一些不需要锁的工作lock.lock();    // 手动加锁// 临界区工作lock.unlock();  // 手动解锁// 更多不需要锁的工作lock.lock();    // 再次加锁// 更多临界区工作} // 如果持有锁，会自动解锁// 2.3 尝试加锁{std::unique_lock<std::mutex> lock(mtx, std::try_to_lock);if (lock.owns_lock()) {// 成功获取锁std::cout << "获取锁成功\n";} else {std::cout << "获取锁失败\n";}}// 2.4 超时加锁（需要timed_mutex）std::timed_mutex timed_mtx;{std::unique_lock<std::timed_mutex> lock(timed_mtx, std::defer_lock);if (lock.try_lock_for(std::chrono::milliseconds(100))) {std::cout << "在100ms内获取锁成功\n";} else {std::cout << "超时，获取锁失败\n";}}// 2.5 移动语义auto create_lock = []() {std::unique_lock<std::mutex> lock(mtx);return lock;  // 可以移动返回};std::unique_lock<std::mutex> moved_lock = create_lock();// moved_lock现在持有锁
}// ============================================
// 3. std::shared_mutex - 读写锁
// ============================================
void shared_mutex_example() {std::shared_mutex rw_mtx;std::string shared_data = "初始数据";// 3.1 读锁 - 多个线程可以同时读auto reader = [&]() {std::shared_lock<std::shared_mutex> read_lock(rw_mtx);std::cout << "读取: " << shared_data << std::endl;// 可以有多个线程同时执行这里};// 3.2 写锁 - 独占访问auto writer = [&]() {std::unique_lock<std::shared_mutex> write_lock(rw_mtx);shared_data = "更新后的数据";std::cout << "写入完成" << std::endl;// 只有一个线程可以执行这里，且会阻塞所有读者};// 启动多个读线程和一个写线程std::vector<std::thread> threads;for (int i = 0; i < 3; ++i) {threads.emplace_back(reader);}threads.emplace_back(writer);for (auto& t : threads) {t.join();}
}// ============================================
// 4. std::recursive_mutex - 递归互斥锁
// ============================================
void recursive_mutex_example() {std::recursive_mutex rec_mtx;int count = 0;std::function<void(int)> recursive_func = [&](int n) {std::lock_guard<std::recursive_mutex> lock(rec_mtx);count++;std::cout << "递归层级: " << n << ", count: " << count << std::endl;if (n > 0) {recursive_func(n - 1);  // 同一线程可以多次获取锁}};recursive_func(3);
}// ============================================
// 5. std::timed_mutex - 超时互斥锁
// ============================================
void timed_mutex_example() {std::timed_mutex timed_mtx;// 5.1 尝试在指定时间内获取锁if (timed_mtx.try_lock_for(std::chrono::milliseconds(100))) {std::cout << "在100ms内获取锁成功\n";// 临界区工作timed_mtx.unlock();} else {std::cout << "超时，获取锁失败\n";}// 5.2 尝试在指定时间点前获取锁auto timeout_time = std::chrono::steady_clock::now() + std::chrono::milliseconds(200);if (timed_mtx.try_lock_until(timeout_time)) {std::cout << "在指定时间点前获取锁成功\n";timed_mtx.unlock();} else {std::cout << "超时，获取锁失败\n";}
}// ============================================
// 6. 多锁管理 - 避免死锁
// ============================================
void multi_lock_example() {std::mutex mtx1, mtx2;// 6.1 std::lock - 同时锁定多个互斥锁，避免死锁{std::lock(mtx1, mtx2);  // 原子性地锁定两个互斥锁std::lock_guard<std::mutex> lock1(mtx1, std::adopt_lock);std::lock_guard<std::mutex> lock2(mtx2, std::adopt_lock);// 临界区代码}// 6.2 std::scoped_lock (C++17) - 更简单的多锁管理{std::scoped_lock lock(mtx1, mtx2);  // 自动管理多个锁// 临界区代码}
}// ============================================
// 7. 条件变量配合使用
// ============================================
void condition_variable_example() {std::mutex mtx;std::condition_variable cv;bool ready = false;// 等待线程auto waiter = [&]() {std::unique_lock<std::mutex> lock(mtx);cv.wait(lock, [&] { return ready; });  // 等待条件满足std::cout << "条件满足，继续执行\n";};// 通知线程auto notifier = [&]() {std::this_thread::sleep_for(std::chrono::milliseconds(100));{std::lock_guard<std::mutex> lock(mtx);ready = true;}cv.notify_one();  // 通知等待的线程};std::thread t1(waiter);std::thread t2(notifier);t1.join();t2.join();
}// ============================================
// 8. 实际应用示例 - 线程安全的计数器
// ============================================
class ThreadSafeCounter {
private:mutable std::mutex mtx_;int count_ = 0;public:void increment() {std::lock_guard<std::mutex> lock(mtx_);++count_;}void decrement() {std::lock_guard<std::mutex> lock(mtx_);--count_;}int get() const {std::lock_guard<std::mutex> lock(mtx_);return count_;}// 复杂操作示例void add_if_positive(int value) {std::unique_lock<std::mutex> lock(mtx_);if (count_ > 0) {count_ += value;}}
};// ============================================
// 9. 性能考虑和最佳实践
// ============================================
void performance_tips() {std::mutex mtx;// ✅ 好的做法：尽量缩小临界区{int temp_result = 0;// 在锁外做复杂计算for (int i = 0; i < 1000; ++i) {temp_result += i * i;}std::lock_guard<std::mutex> lock(mtx);// 只在必要时持有锁// shared_data = temp_result;}// ❌ 不好的做法：在临界区内做复杂计算{std::lock_guard<std::mutex> lock(mtx);// 不要在锁内做复杂计算int result = 0;for (int i = 0; i < 1000; ++i) {result += i * i;}// shared_data = result;}
}int main() {std::cout << "=== C++ 互斥锁使用示例 ===" << std::endl;basic_mutex_example();unique_lock_example();shared_mutex_example();recursive_mutex_example();timed_mutex_example();multi_lock_example();condition_variable_example();// 测试线程安全计数器ThreadSafeCounter counter;std::vector<std::thread> threads;for (int i = 0; i < 10; ++i) {threads.emplace_back([&counter]() {for (int j = 0; j < 100; ++j) {counter.increment();}});}for (auto& t : threads) {t.join();}std::cout << "最终计数: " << counter.get() << std::endl;return 0;
}