[C/C++标准库]_[初级]_[std::vector的多线程读写问题]

最新推荐文章于 2025-09-19 09:00:00 发布
最新推荐文章于 2025-09-19 09:00:00 发布
阅读量1.1w 收藏 6
点赞数 2
CC 4.0 BY-SA版权
分类专栏： C++语言特性和标准库 系统平台 文章标签： c++ vector 崩溃 push_back 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/infoworld/article/details/47343347
本文讨论了在多线程场景下，C++ std::vector在进行push_back和下标访问时可能出现的崩溃问题。尽管可能认为这些操作是线程安全的，但在并发环境中仍可能导致数据不一致。文中通过代码示例展示了问题的发生，并提到了在Visual Studio C++ 2010 SP1环境下遇到的内存异常。为了解决这个问题，作者建议暂时使用C数组作为替代方案。


场景:

1. 有时候需要使用vector 或 map作为多线程的共享变量, map是tree结构, 读和写方法都不是线程安全的, 即同时读写会有崩溃的现象.

2. std::vector直观来说只用push_back和[] 下标访问操作应该没问题,push_back往后边加对象, 索引值只访问已经存储的变量(预先求size).注意, 这里不会删除vector元素.

可惜，这种多线程操作还是会崩溃. 单线程写和单线程读!!!

看代码:

test_vector.cpp

#include "gtest/gtest.h"
#include <vector>
#include <iostream>
#include <Windows.h>
#include "pthread.h"

class A
{
public:
	A(int i):i_(i){}
	int i_;
};

void* first = NULL;
void* second = NULL;

static void* Push(void* data)
{
	std::vector<A*>& vec = *(std::vector<A*>*)data;
	vec.push_back(new A(-1));
	first = std::addressof(vec._Myfirst);
	//std::cout << first << std::endl;
	for(int i = 0; i< 100000;++i)
	{
		vec.pu
了解本专栏 订阅专栏 解锁全文 超级会员免费看
[C/C++标准库]_[初级]_[std::deque和std::vector比较]
小白
06-29 4255
std::deque 特性 双向队列,队列意味着存储方式不一样,deque不是连续存储的. 允许在头尾快速插入或删除,对其他位置的引用对象无影响,不会有copy 发生. 内部存储会根据需要自动扩展,扩展的代价比vector少很多,因为不会创建新的内存并复制引用. 时间复杂度： 1) 随机访问. O(1) 2) 插入和移除头尾元素. O(1) 3) 插入和移除非头尾元素. O(n) std::v
探索C++并发容器：std::vector的线程安全性
夏天的狂风的专栏
06-10 3022
std::vector是C++标准库中的一个动态数组，它可以存储任何类型的元素，并且可以在运行时动态地增加或减少其大小。std::vector提供了一种高效的方式来管理和操作数组，它提供了一组丰富的函数，如push_back、pop_back、insert、erase等，用于添加、删除和修改元素。
跨平台使用C++ vector的多线程问题
01-25 1611
跨平台使用C++ vector的多线程问题源起reserve问题clear问题后记 源起 最近碰到一个linux下程序崩溃的问题，涉及到vector的多线程使用的问题。由于是第二次折腾这个问题，所以把过程记录下来。 简单介绍一下背景：程序为windows和linux跨平台使用。使用一套代码，会分别编译两个平台下的不同版本。 程序涉及的结构。使用了一个全局变量的vector来保存数据，有两个线程，一个线程是周期执行的，每个周期开始时检查全局变量中是否有数据，如果有就取出来处理，然后清空。另一个线程等待外部输入
C++ | 多线程使用vector
RandyOliver's House
06-21 1149
而如果加上第4句，先扩容到1个很大的范围，但是clear仅仅是将成员清除，使得size为0，因此多线程 emplace_back的时候，就能够直接emplace_back了，不会发生扩容问题。多线程需要同时对同一个vector进行写入的时候，先扩容到一个值，避免各个线程单独扩容，保证程序稳定有效进行。第一反应是，既然是Clean函数，肯定就是想清空这个数组，清空之前还要reserve一下，不是多此一举吗？代码单线程测试了一下，也是没问题的，多线程的问题出在哪里呢？问题在于程序使用的是多线程。
C++ 多线程
最新发布
onlymscn的博客
09-19 2116
C++多线程编程指南：从基础到性能优化。文章介绍了C++多线程编程的核心技术，包括线程创建(使用std::thread)、同步机制(互斥锁、条件变量)、线程安全、线程局部存储等基础内容。同时深入探讨了性能优化方法，如减少锁竞争、无锁编程(atomic)、线程池技术、并行算法(C++17)等。文章还提供了常见问题解决方案(数据竞争、死锁等)和性能优化建议(内存模型、伪共享处理等)，并包含完整代码示例，帮助开发者充分利用多核处理器能力，构建高效并发程序。
C++多线程和std::vector
C or CPP
07-18 778
C++ 标准没有定义在一个线程正在修改容器的同时，另一个线程可以安全地读取容器的内容。因此，这种情况下的行为是未定义的，可能导致程序出现不可预测的结果。
多线程操作C++ STL vector出现概率coredump问题分析------切勿对STL 容器的线程安全性有不切实际的依赖!
热门推荐
认知 行动 坚持
07-27 1万+
多线程操作全局变量，必须考虑同步问题，否则可能出现数据不一致， 甚至触发coredump. 前段时间， 遇到一个多线程操作了全局的vector的问题, 程序崩了。场景是这样的：某全局配置参数保存在一个vector中，需要定时更新（更新线程）， 另外的工作线程去读取配置。 这种场景是非常普遍的。 在该场景中，程序没有枷锁，概率coredump, 实际情...
std::vector与std::map的多线程读写问题
个人工作中学到的专业技术与职业发展知识笔记
05-25 7179
STL 语义上不提供任何强度的线程安全保证。 1、vector与map都不是线程安全的： 同时读 OK 同时写 NO == 同时读写== NO 2、vector读写情况： vector一般情况下同时读写读没问题，但当vector预留内存空间不足，需要扩容导致的变量搬移时，读存在问题，同时写也存在问题，因此需要加锁，防止并发执行。 3、map读写情况： map底层结构时红黑树，每插入一个节点，map对下中数据分布就会变，因此，不可以同时写、也不能同时读写。 参考资料： 1、C++ ST
C++ std::lock_guard和 std::unique_lock
m0_59680769的博客
07-16 856
二者都是 C++ 标准库中用于管理互斥锁（mutex）的 RAII（Resource Acquisition Is Initialization）机制的类。这些类可以确保互斥锁在构造时被获取，在析构时被释放，从而避免死锁和资源泄漏问题。不过，它们在功能和使用方式上有一些重要区别。是一个简单的、轻量级的锁管理器，它在构造时获取锁，在析构时释放锁。其主要特点是不能显式地解锁或重新锁定。每个线程在输出信息时获取了互斥锁，确保了标准输出的操作是原子的，避免了竞争条件导致的输出混乱。
std::shared_mutex与std::mutex的不同适用场合
捕鲸叉的专栏
12-01 916
提供了比std::mutex更灵活的同步机制，特别适用于读多写少的场景。通过使用共享锁和独占锁，允许多个线程同时读取共享数据，同时确保写操作的独占性，从而提高了并发性能。在设计和实现多线程程序时，根据具体的应用场景选择合适的同步机制，可以有效提高程序的性能和可维护性。
C++中vector多线程操作
weixin_37684907的博客
11-12 970
C++中vector多线程操作
向量在同一个块中用多个线程执行
09-21
向量在同一个块中用多个线程执行。本实验是启动一个线程块，这个线程块中启动的线程个数为10个。
多线程下读写vector变量
记事本
04-10 4705
考虑到一个线程用于去读数据库，一次性插入多条数据到共享数据区，另外搞2个上的线程去读这个共享数据区，以后打算搞个线程池来处理读部分。 目下的问题是我想把这个共享数据区做成可变化的动态区，当读入数据大时，一次读入全部读完。当数据量小时，则在规范范围的空间中运行。 采用vector方式动态变化，比如要删除超过长度之外的设置，只需要earse就可以了，在线程中每次通过begin，end自动扫描处理中
多线程Vector读写控制
记事本
04-10 5049
最近在做毕设的时候遇到了一个Vector的Iterator意外失效的问题，分析下来，是因为使用了多线程，在对一个成员变量进行读写操作的时候没有加锁导致的，下面有一个编写的简单的例子来说明这个问题。 本例子中使用了ACE_Task(主动对象:ACE中的一种模式，将线程封装在对象中) 问题代码: #pragma once #pragma comment(lib,"ACE
std::vector与std::map的多线程读写问
GXQ的博客
03-29 511
vector一般情况下同时读写读没问题，但当vector预留内存空间不足，需要扩容导致的变量搬移时，读存在问题，同时写也存在问题，因此需要加锁，防止并发执行。参考:https://blog.youkuaiyun.com/qq_33726635/article/details/117200332。map底层结构时红黑树，每插入一个节点，map对下中数据分布就会变，因此，不可以同时写、也不能同时读写。STL 语义上不提供任何强度的线程安全保证。== 同时读写== NO。
arraylist 并发_Java线程安全策略与多线程并发最佳实践
weixin_42382944的博客
12-10 286
线程安全策略不可变对象不可变对象(Immutable Objects)是指对象一旦被创建它的状态(对象的数据，也即对象属性值)就不能改变，任何对它的改变都应该产生一个新的对象。不可变对象需要满足的条件：对象创建以后其状态就不能修改对象所有域都是final类型对象时正确创建的(在对象创建期间，this引用没有逸出)除了使用final自行封装不可变对象之外，还可以通过以下两种方式定义不可变对象Coll...
在多线程中访问vector
h a 6 6 6 c k 为 你解决复杂难题！
03-29 4842
两种情况： 1. 不改变vector的元素数量， 则多线程访问无冲突。 2. 改变vector的元素数量（比如push_back, erase）， 则多线程访问有冲突，需要加锁。 #include <iostream> #include <windows.h> #include <vector> #include <string...
多线程使用--vector是线程安全的，方法同步，使用多线程时效率不高。
weixin_44210987的博客
01-09 9952
看下面的代码 #include <iostream> #include<vector> using std::vector; using std::cout; using std::endl; void isNumEqual5(vector<int>& num) { #pragma omp parallel for for (int i = 0; i < num.size(); i++) { cout << i&l
[C/C++线程安全]_[中级]_[多线程访问修改集合vector会冲突的两个解决方案]
小白
06-21 3559
1. 在开发`C/C++`多线程程序时,`STL`集合类是我们经常用到的类，比如`vector`. 而`C/C++`的这些集合类并没有同步版本，所以在多线程访问时，如果某个线程正在修改集合类`A`, 而其他线程正在访问`A`，那么会造成数据冲突，导致程序抛出异常。这里说的访问`A`,意思是调用`A`的任何方法。难道我们需要在用到`A`的地方对`A`进行加锁？ 麻烦不止，而且很容易造成性能下降。
#include <iostream> #include <memory> // for std::shared_ptr #include "Mutex.h" // #include <shared_mutex> // for std::shared_mutex template <typename T> class CoorPtr { public: CoorPtr() : data_(std::make_shared<T>()) {} ~CoorPtr() = default; // 读取数据（如果数据正在被修改，则触发拷贝） T read() const { // std::shared_lock<std::shared_mutex> lock(mutex_); // 共享锁 bsp::MutexLockGuard lock(mutex_); // 加锁 return *data_; } // 修改数据（独占访问） void write(const T& value) { // std::unique_lock<std::shared_mutex> lock(mutex_); // 独占锁 bsp::MutexLockGuard lock(mutex_); // 加锁 if (!data_.unique()) { // 如果数据被多个对象共享 data_ = std::make_shared<T>(*data_); // 深拷贝数据 } *data_ = value; } private: std::shared_ptr<T> data_; // 共享数据 mutable bsp::MutexLock mutex_; //互斥量 // mutable std::shared_mutex mutex_; // 共享互斥量 }; #endif 这段代码优化一下
03-27
<think>好的，我需要帮助用户优化他们的CoorPtr类，这个类使用了std::shared_ptr和自定义互斥锁来实现线程安全。首先，我得回顾一下用户提供的引用内容，特别是关于std::shared_ptr和线程安全的部分。引用3提到，std::shared_ptr的引用计数是线程安全的，但对象访问需要额外同步。引用2也指出，修改共享指针指向的对象需要同步措施，比如互斥锁。用户的问题是如何优化这样的指针类，所以需要从减少锁的争用、提高效率等方面考虑。 首先，现有的CoorPtr可能使用了全局的互斥锁，这会导致所有操作都串行化，影响性能。优化方向可能包括使用更细粒度的锁，或者将锁与数据绑定，而不是全局锁。例如，每个CoorPtr实例有自己的互斥锁，这样不同实例的操作可以并行，只有同一实例的并发访问需要锁。但用户提到是“自定义互斥锁”，可能当前设计有锁的粒度问题。 其次，检查是否所有操作都需要锁。比如，读取操作是否可以使用更轻量级的机制，比如读写锁（std::shared_mutex），允许多个读操作并发，写操作独占。这能提升读多写少场景的性能。引用5提到shared_ptr的上锁问题，可能涉及到内部实现中的锁策略，但用户这里使用的是自定义锁，可能需要结合现有机制。 另外，考虑使用std::atomic来优化某些操作，比如指针的赋值。但std::shared_ptr本身在拷贝时引用计数是原子的，但直接操作其内部指针可能需要锁。例如，reset或赋值操作可能需要锁来保证线程安全。 还有，检查是否存在不必要的锁范围。比如，在获取数据时，可能只需要在拷贝或访问时加锁，而不是整个函数作用域。缩短锁的持有时间可以减少争用。 另外，考虑是否可以使用std::weak_ptr来避免循环引用，但用户的问题主要是优化线程安全的实现，可能这方面不是重点，但如果有循环引用的问题，这也是一个优化点（引用1、3）。 可能还需要考虑移动语义，避免不必要的拷贝，减少锁的使用。比如，在CoorPtr的移动构造函数中，是否可以转移资源所有权而无需加锁？ 此外，异常安全也需要考虑，确保在加锁期间不发生异常导致死锁，可以使用RAII管理锁，如std::lock_guard或std::unique_lock，确保即使发生异常也能释放锁。 总结可能的优化点： 1. 将全局锁改为每个实例独立的锁，提高并发性。 2. 使用读写锁区分读/写操作。 3. 减少锁的持有时间，仅在必要操作时加锁。 4. 利用移动语义减少拷贝开销。 5. 检查是否存在循环引用，引入std::weak_ptr。 6. 使用RAII管理锁，确保异常安全。 7. 避免在锁内执行可能耗时的操作，如I/O或复杂计算。 接下来需要具体实现这些优化。比如，修改锁的粒度，每个CoorPtr对象拥有自己的互斥锁。读写操作使用读写锁，例如读操作用std::shared_lock，写操作用std::unique_lock。此外，在拷贝或移动时正确处理锁和指针的所有权转移。 另外，参考引用5提到的shared_ptr的上锁问题，可能需要确保在多线程环境下，对shared_ptr本身的复制或赋值操作是线程安全的。根据引用3，shared_ptr的引用计数操作是线程安全的，但指向的对象访问需要同步。因此，在CoorPtr中，每次通过get()访问原始指针时，需要加锁保护，确保在访问期间对象不被修改。 可能的代码结构优化示例： 原类可能类似： class CoorPtr { std::shared_ptr<Data> data; std::mutex mtx; public: void set(const Data& newData) { std::lock_guard<std::mutex> lock(mtx); data = std::make_shared<Data>(newData); } std::shared_ptr<Data> get() { std::lock_guard<std::mutex> lock(mtx); return data; } }; 优化后可能使用读写锁： #include <shared_mutex> class CoorPtr { std::shared_ptr<Data> data; mutable std::shared_mutex rw_mutex; public: void set(const Data& newData) { std::unique_lock<std::shared_mutex> lock(rw_mutex); data = std::make_shared<Data>(newData); } std::shared_ptr<Data> get() const { std::shared_lock<std::shared_mutex> lock(rw_mutex); return data; } }; 这样，多个线程可以同时调用get()进行读取，而set()操作会独占锁。同时，确保移动和拷贝构造正确处理锁和指针的转移，避免死锁。 另外，如果Data对象的修改频繁，可能需要将锁的范围缩小到仅保护shared_ptr的替换，而不是整个Data的访问。例如，如果Data本身是线程安全的，可能不需要额外锁，但通常需要用户自己保证。 总之，优化重点在于锁的粒度、类型以及操作的线程安全处理，结合shared_ptr的特性进行设计。</think>### 优化C++线程安全指针类CoorPtr的实现步骤 #### 1. **使用读写锁提升并发性能** - 将普通互斥锁`std::mutex`替换为`std::shared_mutex`，区分读/写操作： ```cpp #include <shared_mutex> class CoorPtr { std::shared_ptr<Data> data; mutable std::shared_mutex rw_mutex; // 可变的读写锁 public: // 写操作使用独占锁 void set(const Data& newData) { std::unique_lock<std::shared_mutex> lock(rw_mutex); data = std::make_shared<Data>(newData); } // 读操作使用共享锁 std::shared_ptr<Data> get() const { std::shared_lock<std::shared_mutex> lock(rw_mutex); return data; } }; ``` - **优势**：允许多线程同时读取，减少锁争用[^2][^3]。 #### 2. **缩小锁的作用范围** - 仅在必须同步的操作中加锁，避免锁持有时间过长： ```cpp void updateData() { auto temp = std::make_shared<Data>(...); // 外部构造临时对象 { std::unique_lock<std::shared_mutex> lock(rw_mutex); data.swap(temp); // 快速替换指针 } // 锁外释放旧数据资源 } ``` - **优势**：减少锁的占用时间，提升并发效率。 #### 3. **支持移动语义减少拷贝** - 通过移动构造函数和移动赋值传递资源所有权： ```cpp CoorPtr(CoorPtr&& other) noexcept { std::unique_lock<std::shared_mutex> lock(other.rw_mutex); data = std::move(other.data); } CoorPtr& operator=(CoorPtr&& other) noexcept { if (this != &other) { std::unique_lock<std::shared_mutex> lock1(rw_mutex, std::defer_lock); std::unique_lock<std::shared_mutex> lock2(other.rw_mutex, std::defer_lock); std::lock(lock1, lock2); // 避免死锁 data = std::move(other.data); } return *this; } ``` - **优势**：避免不必要的拷贝，提升性能。 #### 4. **使用RAII管理锁** - 通过`std::lock_guard`或`std::unique_lock`自动管理锁生命周期： ```cpp void threadSafeOperation() { std::shared_lock<std::shared_mutex> readLock(rw_mutex); // 自动释放 if (data) { data->safeReadOperation(); } } ``` - **优势**：确保异常安全，避免锁泄漏[^3]。 #### 5. **避免循环引用** - 若类内部存在相互引用，使用`std::weak_ptr`打破循环： ```cpp class Node { std::shared_ptr<Node> parent; std::weak_ptr<Node> child; // 使用weak_ptr避免循环 }; ``` - **优势**：防止内存泄漏[^1]。 #### 6. **线程安全验证与测试** - 通过压力测试验证多线程场景下的正确性： ```cpp void concurrentTest() { CoorPtr ptr; std::vector<std::thread> threads; for (int i = 0; i < 10; ++i) { threads.emplace_back([&]() { ptr.set(Data{i}); // 多线程写 auto localCopy = ptr.get(); // 多线程读 }); } for (auto& t : threads) t.join(); } ``` - **优势**：确保优化后仍满足线程安全要求。 ### 总结 优化后的`CoorPtr`通过细粒度读写锁、移动语义和RAII机制，显著提升了多线程环境下的性能和安全性，同时避免了循环引用导致的内存泄漏问题。
评论 6
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

白行峰 (花名)

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值