容器本身const但元素非const时，多线程环境下是否需加锁？

你的判断是对的——因为容器初始化后是const且结构完全不变（不会增删元素、不会改变容器的内存布局），所以访问容器获取元素指针/引用时不需要加锁，只需要在读写元素内部的共享数据时加锁即可，这样能有效避免死锁。

核心原因 #

C++标准规定：对于容器的只读操作（比如size()、operator[]访问元素），只要没有其他线程同时修改容器本身，就是线程安全的。你的m_collection是const std::vector<CustomClass*>，初始化后不会有任何修改容器结构的操作（比如push_back、erase），所以多个线程同时调用GetObject访问容器是安全的，不会出现数据竞争。

针对你的代码分析 #

1. GetObject函数：不需要加锁。m_collection.size()和m_collection[index]都是只读操作，容器结构不变的情况下，这些操作是线程安全的。另外注意size_t是无符号类型，index >= 0的判断是多余的，可以删掉。

2. AdjustValue函数：调用GetObject不需要锁，拿到CustomClass*后，修改m_value的时候必须加锁（或者用原子类型），因为m_value是多个线程可能同时读写的共享数据。

修正后的代码示例 #

推荐给CustomClass添加互斥锁来保证m_value的线程安全，或者用std::atomic<int>更高效：

方案1：用互斥锁

#include "CustomClass.h"
#include <vector>
#include <mutex>

class CustomClass
{
public:
   CustomClass() : m_value(0) {}

   int GetValue() {
       std::lock_guard<std::mutex> lock(m_mutex);
       return m_value;
   }

   void IncrementValue() {
       std::lock_guard<std::mutex> lock(m_mutex);
       m_value++;
   }

private:
   int m_value;
   std::mutex m_mutex;
};

class CustomCollection
{
public:
   CustomCollection() : m_collection(CreateCustomCollection()) {}

   CustomClass* GetObject(const size_t index)
   {
       if(index < m_collection.size())
       {
           return m_collection[index];
       }
       return nullptr;
   }

   void AdjustValue()
   {
       CustomClass* custom_object = GetObject(0);
       if(custom_object)
       {
           custom_object->IncrementValue(); // 这里内部已经加锁
       }
   }

private:
   static const std::vector<CustomClass*> CreateCustomCollection()
   {
       std::vector<CustomClass*> collection;
       collection.push_back(new CustomClass());
       return collection;
   }

   const std::vector<CustomClass*> m_collection;
};

方案2：用原子类型（适合简单整数操作）

#include <atomic>

class CustomClass
{
public:
   CustomClass() : m_value(0) {}

   std::atomic<int> m_value;
};

// CustomCollection类不需要修改，AdjustValue里直接操作即可：
void AdjustValue()
{
   CustomClass* custom_object = GetObject(0);
   if(custom_object)
   {
       custom_object->m_value++; // atomic操作本身是线程安全的
   }
}

关键注意事项 #

• 必须严格保证容器的不可变性：初始化后绝对不能对容器进行任何修改结构的操作，哪怕是单线程也不行，否则所有线程安全的前提都会失效。
• 元素的线程安全要独立保证：每个元素的内部数据访问都需要同步，如果多个线程操作同一个元素，必须通过锁或原子类型保护；如果操作不同元素，各自的锁不会冲突，能有效避免死锁。
• 死锁规避：因为不需要在访问容器时持有锁，仅在操作元素时加锁，只要保证同时操作多个元素时按固定顺序加锁（比如按元素索引从小到大加锁），就能彻底避免死锁问题。

内容的提问来源于stack exchange，提问作者Ricky