《C++并发编程实战》 第3章 在线程间共享数据

最新推荐文章于 2025-12-05 20:00:00 发布
原创 最新推荐文章于 2025-12-05 20:00:00 发布 · 192 阅读 · 5 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #开发语言

3.2.1　在C++中使用互斥

C++17引入了一个新特性，名为类模板参数推导。于std::lock_guard<>可以直接简化为std::lock_guard guard(some_mutex);

3.2.3　发现接口固有的条件竞争

在这里插入图片描述

两难境地

pop的两种设计方法，一个是想用empty检查，再pop数据
另外一个是直接怕pop数据 — 这种方法存在巨大风险
在这里插入图片描述
在这里插入图片描述

解决方法

在这里插入图片描述
在这里插入图片描述在这里插入图片描述

在这里插入图片描述

实例

#include <iostream>
#include <thread>
#include <memory>
#include <mutex>
#include <stack>

struct empty_stack : std::exception
{
    const char *what() const throw();
};

template <typename T>
class threadsafe_stack
{
private:
    std::stack<T> data;
    mutable std::mutex m;

public:
    threadsafe_stack() {}
    threadsafe_stack(const threadsafe_stack &other)
    {
        std::lock_guard<std::mutex> lock(other.m);
        data = other.data;
    }
    threadsafe_stack &operator=(const threadsafe_stack &) = delete;
    void push(T new_value)
    {
        std::lock_guard<std::mutex> lock(m);
        data.push(new_value);
    }
    std::shared_ptr<T> pop()
    {
        std::lock_guard<std::mutex> lock(m);
        if (data.empty())
            throw empty_stack();
        std::shared_ptr<T> const res(std::make_shared<T>(data.top()));
        data.pop();
        return res;
    }
    void pop(T &value)
    {
        std::lock_guard<std::mutex> lock(m);
        if (data.empty())
            throw empty_stack();
        value = data.top();
        data.pop();
    }
    bool empty() const
    {
        std::lock_guard<std::mutex> lock(m);
        return data.empty();
    }
};

死锁的预防

同时加锁

在这里插入图片描述
在这里插入图片描述

预防原则

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述


#include <iostream>
#include <mutex>
#include <stdexcept> // 用于 std::logic_error
#include <climits>   // 用于 ULONG_MAX

// ==========================================
// 层级锁类的定义
// ==========================================
class hierarchical_mutex
{
    std::mutex internal_mutex;              // 内部真正的锁
    const unsigned long hierarchy_value;    // 当前锁的层级值（固定不变）
    unsigned long previous_hierarchy_value; // 保存加锁前的层级值（用于解锁时恢复）

    // 关键点：thread_local
    // 每个线程都有自己独立的“当前层级值”，互不干扰。
    // 初始值为 ULONG_MAX，表示线程刚开始没有持有任何锁，权力无限大。
    // 这里的static很重要，表示这个变量属于类，而不是某个对象实例。表示一个对象加一次锁就会改动这个值。
    static thread_local unsigned long this_thread_hierarchy_value;

public:
    explicit hierarchical_mutex(unsigned long value) : hierarchy_value(value), previous_hierarchy_value(0) {}

    // 核心检查逻辑
    void check_for_hierarchy_violation()
    {
        // 规则：线程当前的层级必须【严格大于】想要获取的锁的层级
        // 如果我现在手里拿着 5000 的锁，我就不能去拿 6000 的锁（向上加锁，禁止）
        // 我也不能去拿另一个 5000 的锁（平级加锁，禁止，防止循环等待）
        if (this_thread_hierarchy_value <= hierarchy_value)
        {
            throw std::logic_error("互斥锁层级违规 (Mutex hierarchy violated)");
        }
    }

    // 更新线程状态
    void update_hierarchy_value()
    {
        // 1. 记下老的值，比如原来是无穷大(ULONG_MAX)
        previous_hierarchy_value = this_thread_hierarchy_value;
        // 2. 把线程现在的“水位”降低到当前锁的层级
        this_thread_hierarchy_value = hierarchy_value;
    }

    void lock()
    {
        // 1. 检查是否合规
        check_for_hierarchy_violation();
        // 2. 物理加锁（可能会阻塞）
        internal_mutex.lock();
        // 3. 更新当前线程的层级记录
        update_hierarchy_value();
    }

    void unlock()
    {
        // 1. 恢复之前的层级值。
        // 例如：我先拿了10000(High)，又拿了5000(Low)。
        // 解锁Low时，必须把我的层级从5000恢复回10000，这样我才能去释放High或者拿其他<10000的锁。
        this_thread_hierarchy_value = previous_hierarchy_value;
        // 2. 物理解锁
        internal_mutex.unlock();
    }

    bool try_lock()
    {
        check_for_hierarchy_violation();
        if (!internal_mutex.try_lock())
            return false;
        update_hierarchy_value();
        return true;
    }
};

// 初始化类的静态成员变量
// thread_local 变量在每个线程启动时会自动初始化为 ULONG_MAX
thread_local unsigned long hierarchical_mutex::this_thread_hierarchy_value(ULONG_MAX);

// ==========================================
// 测试部分
// ==========================================

// 定义两个锁：一个高层级，一个低层级
// 规则：必须先锁 High，再锁 Low (10000 -> 5000)
hierarchical_mutex high_level_mutex(10000);
hierarchical_mutex low_level_mutex(5000);

void test_correct_order()
{
    std::cout << "\n=== 测试 1: 正确的加锁顺序 (高 -> 低) ===" << std::endl;
    try
    {
        std::cout << "[Step 1] 尝试锁定 High(10000)..." << std::endl;
        high_level_mutex.lock();
        std::cout << "         锁定 High 成功。" << std::endl;

        std::cout << "[Step 2] 尝试锁定 Low(5000)..." << std::endl;
        // 当前线程层级是 10000，目标是 5000。 10000 > 5000，允许。
        low_level_mutex.lock();
        std::cout << "         锁定 Low 成功。" << std::endl;

        // 执行任务...
        std::cout << "         (执行临界区任务...)" << std::endl;

        low_level_mutex.unlock();
        std::cout << "         解锁 Low。" << std::endl;

        high_level_mutex.unlock();
        std::cout << "         解锁 High。" << std::endl;
    }
    catch (const std::exception &e)
    {
        std::cout << "!!! 发生异常: " << e.what() << std::endl;
    }
}

void test_wrong_order()
{
    std::cout << "\n=== 测试 2: 错误的加锁顺序 (低 -> 高) ===" << std::endl;
    try
    {
        std::cout << "[Step 1] 尝试锁定 Low(5000)..." << std::endl;
        low_level_mutex.lock();
        std::cout << "         锁定 Low 成功。当前线程层级降为 5000。" << std::endl;

        std::cout << "[Step 2] 尝试锁定 High(10000)..." << std::endl;
        // 当前线程层级是 5000，目标是 10000。
        // 检查：5000 <= 10000 ? 是的。
        // 结果：触发异常！
        high_level_mutex.lock();

        // 下面这行永远不会执行
        std::cout << "         锁定 High 成功 (不应该发生!)。" << std::endl;
        high_level_mutex.unlock();
        low_level_mutex.unlock();
    }
    catch (const std::exception &e)
    {
        std::cout << "!!! 捕获到预期异常: " << e.what() << std::endl;
        std::cout << "    说明层级锁机制生效了，防止了潜在的死锁风险。" << std::endl;

        // 清理现场：因为异常跳出了，我们需要手动释放刚才锁住的 low_mutex
        // (在实际C++项目中，通常建议使用 std::lock_guard 来自动处理这个，这里为了演示手动调用 unlock)
        low_level_mutex.unlock();
    }
}

int main()
{
    test_correct_order();
    test_wrong_order();
    return 0;
}


// ==========================================
// 全局锁定义
// ==========================================
hierarchical_mutex m_bank_gate(10000); // 银行大门（高层级）
hierarchical_mutex m_vault(5000);      // 内部金库（低层级）

// 辅助打印函数（加锁防止cout乱序）
std::mutex cout_mutex;
void print_status(const std::string& name, const std::string& msg) {
    std::lock_guard<std::mutex> lk(cout_mutex);
    std::cout << "[" << name << "] " << msg 
              << " | 当前层级值: " << hierarchical_mutex::get_current_thread_hierarchy_value() 
              << std::endl;
}

在这里插入图片描述

// ==========================================
// 线程 A：行长 (遵守规则)
// ==========================================
void manager_thread() {
    std::string name = "行长 A";
    try {
        print_status(name, "上班了，准备开大门(10000)...");
        m_bank_gate.lock(); // 1. 先锁高层级
        print_status(name, "大门已锁好，准备开金库(5000)...");
        
        // 模拟一点业务延迟，让大家有机会并发
        std::this_thread::sleep_for(std::chrono::milliseconds(100));

        m_vault.lock();     // 2. 再锁低层级
        print_status(name, "金库已打开！正在清点钞票...");
        
        // 这里的层级检查逻辑：
        // 当前是 10000，目标是 5000 -> OK -> 当前变为 5000
        
        m_vault.unlock();   // 解锁金库，层级恢复为 10000
        print_status(name, "金库关闭。");
        
        m_bank_gate.unlock(); // 解锁大门，层级恢复为 ULONG_MAX
        print_status(name, "下班回家。");
    }
    catch (const std::exception& e) {
        print_status(name, std::string("发生异常: ") + e.what());
    }
}

// ==========================================
// 线程 B：小偷 (违反规则)
// ==========================================
void thief_thread() {
    std::string name = "小偷 B";
    // 让行长先跑一步，演示并发互不干扰
    std::this_thread::sleep_for(std::chrono::milliseconds(50));
    
    try {
        print_status(name, "潜入中... 试图直接控制金库(5000)...");
        m_vault.lock(); // 1. 先锁低层级
        print_status(name, "成功控制金库！现在想反锁大门(10000)...");

        // 此时，线程 B 的 thread_local 变量值为 5000。
        
        // 2. 试图去锁高层级
        // 检查：当前(5000) <= 目标(10000) ？ 是！
        // 结果：抛出异常
        m_bank_gate.lock(); 
        
        // 下面永远不会执行
        print_status(name, "大门锁上了 (不可能发生)");
        m_bank_gate.unlock();
        m_vault.unlock();
    }
    catch (const std::exception& e) {
        // 捕获异常
        std::lock_guard<std::mutex> lk(cout_mutex);
        std::cout << "\n>>> [" << name << "] ！！！被抓住了！！！ <<<" << std::endl;
        std::cout << "    错误原因: " << e.what() << std::endl;
        std::cout << "    (证明：即使是不同的线程，层级锁也能精准拦截逻辑错误)\n" << std::endl;
        
        // 记得释放金库锁，否则行长下次来就进不去了（虽然本例中程序结束了）
        m_vault.unlock(); 
    }
}

int main() {
    std::thread t1(manager_thread);
    std::thread t2(thief_thread);

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

    return 0;
}

3.2.7　在不同作用域之间转移互斥归属权

通道（Gateway）类

在这里插入图片描述

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

class DataManager
{
private:
    std::vector<int> _data; // 数据是私有的，外部完全不可见
    std::mutex _mutex;      // 锁也是私有的

public:
    // 这就是文中所说的 “通道（Gateway）类”
    class Gateway
    {
        // 【关键点1】锁是它的数据成员
        std::unique_lock<std::mutex> _guard;
        // 持有数据的引用，以便操作
        std::vector<int> &_ref_to_data;

    public:
        // 构造时：接收锁的所有权（上锁），并接收数据引用
        Gateway(std::mutex &m, std::vector<int> &d)
            : _guard(m), _ref_to_data(d)
        {
            std::cout << "  [Gateway] 通道已建立，已上锁。\n";
        }

        // 默认生成移动构造函数（因为 unique_lock 可移动）
        // 这满足了文中“通道对象几乎是可移动的”的要求
        Gateway(Gateway &&) = default;
        // 【关键点2】必须通过 Gateway 的成员函数才能访问数据
        void add(int value)
        {
            std::cout << "  [Gateway] 操作数据: 添加 " << value << "\n";
            _ref_to_data.push_back(value);
        }

        void print()
        {
            std::cout << "  [Gateway] 当前数据: ";
            for (int i : _ref_to_data)
                std::cout << i << " ";
            std::cout << "\n";
        }

        // 析构时：_guard 自动销毁，锁随之释放
        ~Gateway()
        {
            std::cout << "  [Gateway] 通道销毁，锁释放。\n";
        }
    };
    // 外部获取 Gateway 的唯一入口
    Gateway get_access()
    {
        // 返回 Gateway 实例。
        // 这里的 return 会触发移动语义，把锁的归属权转移给调用者。
        return Gateway(_mutex, _data);
    }
};

void worker(DataManager &manager, int id)
{
    // 1. 获取通道对象（此时已经上锁）
    // 这一步对应文中“需先取得通道类的实例...再借它执行加锁操作”
    DataManager::Gateway gate = manager.get_access();

    // 2. 通过通道操作数据
    gate.add(id);
    gate.print();

    // 3. 函数结束，gate 销毁，自动解锁
}

int main()
{
    DataManager my_manager;

    std::thread t1(worker, std::ref(my_manager), 100);
    std::thread t2(worker, std::ref(my_manager), 200);

    t1.join();
    t2.join();
    return 0;
}

class DataManager
{
private:
    std::vector<int> _data; // 数据是私有的，外部完全不可见
    std::mutex _mutex;      // 锁也是私有的

public:
    void add(int value)
    {
        std::lock_guard<std::mutex> lock(_mutex);
        _data.push_back(value);
    }

    void print()
    {
        std::cout << "  [Gateway] 当前数据: ";
        for (int i : _data)
            std::cout << i << " ";
        std::cout << "\n";
    }
};
gateway设计的优势

在这里插入图片描述
优势： Gateway 把多个步骤打包成了一个**“事务（Transaction）”**。只要 Gateway 对象还在，没人能打断你的一系列操作。
在这里插入图片描述

实现线程安全的其他手段

初始化过程中保护

  • one_flag,call_once
  • 利用static变量在C++11中的新规定

保护很少需要更新的数据

  • 使用读写锁
    在这里插入图片描述

递归锁

yangpipi-
关注
C++并发编程--第三章--线程间共享数据
qls315的博客
06-15 1044
1. 线程间共享数据存在的问题 所有线程间共享数据的问题，都是修改数据导致的（竞争条件）。如果所有的共享数据都是只读的，就没问题，因为一个线程所读取的数据不受另一个线程是否正在读取相同的数据而影响。（引用https://blog.youkuaiyun.com/xy_cpp/article/details/80646443）。 2. 利用锁(mutex)保护共享数据 2.1 使用C++11中的std::mutex 在C++11中，你可以通过std::mutex的构造函数创建一个std::mutex实例，通过调用l
C++并发编程实战 第三章 在线程间共享数据
qq_52758467的博客
09-26 480
private:public:// 1 在构造函数体中的执行拷贝// 在调用pop前，检查栈是否为空// 在修改堆栈前，分配出返回值data.pop();return res;data.pop();
C++并发编程实战 第三章 线程间共享数据
_
12-26 702
add_to_list() 和 list_contains() 函数使用 std::lock_guard 来确保对 some_list 的访问是互斥的，即一个线程在修改列表时，其他线程不能读取或修改该列表。除了上述特性外，std::unique_lock 还支持锁所有权的转移，这意味着你可以将一个 std::unique_lock 持有的锁转移给另一个 std::unique_lock 实例。因为两个线程可能尝试在相同的一对实例之间交换数据，但选择了相反的锁定顺序，从而导致死锁。
《C++并发编程实战》精读总结：第三章 在线程间共享数据
见牛羊的博客
03-06 244
多线程数据共享的问题多是由于对数据的改动引起的，要对共享的数据进行保护，比较直接的方法就是实用互斥和加锁。下面看一个简单的例子，使用到了互斥mutex，和对互斥加锁lock_guard<>。这里，假设一个线程调用add向stack1里添加元素时，如果另外一个线程调用top_value想要看stack顶部的元素是无法做到的，因为add已经锁住了互斥mutex1。注意，互斥标记的是代码。锁住互斥就是锁住标记代码涉及到的共享数据。
[笔记]C++并发编程实战 《三》线程间共享数据
二次元怪兽的博客
05-29 911
本章主要内容共享数据带来的问题使用互斥量保护数据数据保护的替代方案本章讨论了当两个线程间的共享数据发生恶性条件竞争时，将会带来多么严重的灾难，还讨论了如何使用 std::mutex 和如何避免这些问题。如你所见，虽然C++标准库提供了一写工具来避免这些(例如： std::lock() )，互斥量并不是灵丹妙药，也还有自己的问题(比如：死锁)。还见识了一些用于避免死锁的先进技术，之后了解了锁的所有权转移，以及一些围绕如何选取适当粒度锁产生的问题。
《C++并发编程实战》笔记-第3章在线程间共享数据
qq_42692132的博客
06-19 159
并发编程的基础工具
【C++】《C++ 并发编程实战 (第2版) 》笔记-Chapter3-在线程间共享数据
江湖人称菠萝包
05-04 1106
三、在线程间共享数据 用互斥保护共享数据 在 C++ 中，我们通过构造 std::mutex 的实例来创建互斥，调用成员函数 lock() 对其加锁，调用 unlock() 解锁。 C++ 标准库提供了类模板 std::lock_guard<>，针对互斥类融合实现了 RAII 手法：在构造时给互斥加锁，在析构时解锁，从而保证互斥总被正确解锁。 std::mutex 和 std::lock_guard<> 都在头文件里声明。 C++17 引入了一个新特性，名为类模板参数推断，对于
C++ 并发编程实战 第八章 设计并发代码 一
qq_52758467的博客
10-01 421
就能对应用的性能有所改善。因此，当数据已传播，将会有更多的缓存行从处理器的缓存上加载数据，这会增加访问内存的延迟，以及降低数据的性能(与紧凑的数据存储地址相比较)。当处理器切换线程时，要对不同内存行上的数据进行加载(当不同线程使用的数据跨越了多个缓存行时)，而非对缓存中的数据保持原样(当线程中的数据都在同一缓存行时)。这个问题的解决办法就是对数据进行构造，让同一线程访问的数据项存在临近的地址中(就像是放在同一缓存行中)，这样那些能被独立线程访问的数据将分布在相距很远的地方，并且可能是存储在不同的缓存行中。
C++并发编程实战（第2版）第三章
lichengyang的博客
10-06 472
C++17新提供，与std::lock_guard完全等价，只不过std::scoped_lock可以接受多个mutex互斥对象作为构造函数的参数。读时共享，写时互斥。需要与一个标记结合使用，这个标记std::once_flag,函数被调用后std::once_flag就被设置为已调用状态;2. std::try_to_lock //自己不能先去lock();3. std::defer_lock //自己不能先去lock();1. std::adopt_lock //只析构解锁，不上锁。
C++并发编程之二 在线程间共享数据
Awesomewan的博客
03-07 1887
C++并发之探索编程二实战
C++并发编程实战:示例源源码
06-14
《C++并发编程实战》是一本深入探讨C++并发编程技术的书籍，其源码库名为Cpp-Concurrency-in-Action-master。并发编程是现代多核处理器环境下提高软件性能的关键技术，C++作为一门强大且灵活的编程语言，提供了丰富...
C++并发编程实战 源码 (C++ Concurrency in Action)
08-04
《C++并发编程实战》是C++领域中一本深入探讨并发和多线程编程的经典著作。这本书通过大量的实例代码，详细介绍了如何在C++中高效地实现并发操作，以充分利用现代多核处理器的性能。以下将针对源码文件名中的几个...
C++并发编程实践 C++ Concurrency in Action
12-11
第三章重点讲述了如何在线程之间安全地共享数据。当多个线程访问同一资源时，可能会引发竞态条件（race condition），导致不可预测的行为。 - **互斥量**：`std::mutex`用于保护临界区，确保任何时候只有一个线程...
[C++]string类的使用和模拟实现
我的博客
12-01 884
本文系统介绍了C++中string类的使用与实现方法。首先分析了string类的函数风格，包括参数传递方式、const与非const迭代器区别及隐式类型转换特性。然后详细讲解了string类的核心实现，包括构造函数、析构函数、拷贝构造等基础功能，以及迭代器、容量操作等内联函数实现。重点剖析了字符串的增删查改操作，如扩容机制、插入删除算法等实现细节，并指出了常见错误点（如'\0'处理、size_t循环问题）。通过具体代码示例展示了operator>>、insert等关键函数的实现逻辑，帮助读者掌握
c++——探讨a÷b（long long)
12-02 289
见正文
C语言 函数
cja0222的博客
12-01 921
在C语言的世界里，函数不仅是代码组织的基本单元，更是程序员构建复杂系统的思维工具。从简单的 main()函数到庞大的库函数集合，函数贯穿了C语言的每个角落。重要的是自定义函数。自定义函数和库函数一样，有函数名，返回值类型和函数参数。所谓自定义就是这些都是我们自己来设计。这给我们自己一个很大的发挥空间。ret_type fun_name(形式参数)//ret_type是函数返回类型//fun_name是函数名// ()括号中放的是形式参数//{}括起来的是函数体。
C++ 设计模式之单例模式详细介绍
XiaoBinbest的博客
12-01 1470
唯一性：类的实例在整个程序中只能有一个，禁止外部通过new、拷贝等方式创建多个实例。全局访问：提供一个静态方法（如），让程序任何地方都能便捷访问该实例。可控初始化：根据需求选择“提前初始化”（饿汉式）或“延迟初始化”（懒汉式），平衡资源占用与启动速度。实现方式线程安全（C++11+）延迟初始化代码复杂度内存泄漏风险推荐优先级Meyers 单例（局部静态）是是极低无★★★★★饿汉式（全局静态）是否低无★★★★☆懒汉式（互斥锁）是是中有（需手动销毁）
LinuxC语言并发程序笔记补充
chenzhou__的博客
12-04 625
锁除了互斥锁，还有一个读写锁，进程通信还有对互斥锁优化的条件变量和死锁的概念。
单片机 使用 cJson 添加 无符号 32 位数值（uint32_t）溢出问题的解决办法
最新发布
weixin_46158019的博客
12-05 333
的最大值（2147483647）时，数据不正常。，使用的是 ARMCC 系统工具链 ，文件。单片机 使用在 cJSON 中添加无符号32位（）数据出现「溢出」。）数据 ，超过 有符号32位(，查看此函数 调用关系 —>cJson 使用的函数是。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值