学懂C++（二十六）：高级教程——深入详解 C++ 锁（Lock）在多线程开发中的应用

猿享天开

已于 2024-08-15 14:04:46 修改

阅读量512

点赞数 6

分类专栏：学懂C++语言-C++核心编程精讲文章标签： c++ 多线程开发语言锁（Lock）

于 2024-08-13 11:28:32 首次发布

本文链接：https://blog.csdn.net/martian665/article/details/141159156

版权

学懂C++语言-C++核心编程精讲专栏收录该内容

61 篇文章 22 订阅

订阅专栏

引言

多线程编程使得我们能够充分利用现代处理器的多核特性，从而提高应用的性能。然而，多线程也带来了诸如数据竞争和不一致性的问题。在 C++ 中，锁（Lock）机制是解决这些问题的重要工具。本文将深入探讨 C++ 中的不同类型的锁，包括互斥锁、递归锁和共享锁，并结合示例解析其应用。

1. 锁的基本概念

锁是用于同步线程与保护共享资源的一种机制。通过锁，我们可以确保同一时间只有一个线程可以访问特定的代码区域或资源。C++11 引入了一系列标准锁，主要包括：

互斥锁（std::mutex）：保证同一时刻只有一个线程访问共享资源。
递归锁（std::recursive_mutex）：允许同一线程多次获取锁。
共享锁（std::shared_mutex）：允许多个线程同时读取，但在写入时需要独占。

2. 互斥锁（std::mutex）

2.1 使用示例

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

std::mutex mtx;               // 互斥锁
int shared_counter = 0;       // 共享计数器

void increment(int id, int iterations) {
    for (int i = 0; i < iterations; ++i) {
        mtx.lock();           // 加锁
        ++shared_counter;     // 访问共享资源
        std::cout << "Thread " << id << " incremented counter to " << shared_counter << std::endl;
        mtx.unlock();         // 解锁
    }
}

int main() {
    const int thread_count = 5;
    const int iterations = 10;
    std::vector<std::thread> threads;

    for (int i = 0; i < thread_count; ++i) {
        threads.emplace_back(increment, i, iterations);
    }

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

    std::cout << "Final counter value: " << shared_counter << std::endl;
    return 0;
}

2.2 代码解析

互斥锁 用于保护 shared_counter，确保同一时间只有一个线程可以访问它。
代码的执行结果将确保 Final counter value 始终为 50，表明所有的增量操作都是安全的。

3. 递归锁（std::recursive_mutex）

3.1 使用场景

当一个线程需要在持有锁的情况下再次获取锁时，递归锁能够避免死锁的发生。

3.2 示例代码

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

std::recursive_mutex rmtx;   // 递归锁
int shared_counter = 0;

void recursive_increment(int id, int depth) {
    if (depth <= 0) return;

    rmtx.lock();                // 加锁
    ++shared_counter;           // 访问共享资源
    std::cout << "Thread " << id << " incremented counter to " << shared_counter << " at depth " << depth << std::endl;
    recursive_increment(id, depth - 1); // 递归调用
    rmtx.unlock();              // 解锁
}

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

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

    std::cout << "Final counter value: " << shared_counter << std::endl;
    return 0;
}

3.3 代码解析

在这个示例中，recursive_increment 函数可以递归调用，每次调用都需要获取同一个锁。这是递归锁的优势所在，它允许同一线程多次获取锁而不会造成死锁。

4. 共享锁（std::shared_mutex）

4.1 使用场景

共享锁允许多个线程同时读取共享资源，但在进行写入时需要独占锁。这种锁适用于读多写少的场景。

4.2 示例代码

#include <iostream>
#include <thread>
#include <shared_mutex>
#include <vector>

std::shared_mutex shm;        // 共享锁
int shared_data = 0;

void read_data(int id) {
    shm.lock_shared();         // 共享锁
    std::cout << "Thread " << id << " read data: " << shared_data << std::endl;
    shm.unlock_shared();       // 释放共享锁
}

void write_data(int id, int value) {
    shm.lock();                // 独占锁
    shared_data = value;
    std::cout << "Thread " << id << " wrote data: " << shared_data << std::endl;
    shm.unlock();              // 释放独占锁
}

int main() {
    std::vector<std::thread> threads;

    // 创建多个读线程
    for (int i = 0; i < 5; ++i) {
        threads.emplace_back(read_data, i);
    }

    // 创建一个写线程
    threads.emplace_back(write_data, 1, 42);

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

    return 0;
}