@ohos-graphics/stability-code-review 0.1.0

package/references/ConcurrencyStability/StabilityCodeReview_ConcurrencyStability_001.md

@@ -0,0 +1,414 @@
+---
+rule_id: "StabilityCodeReview_ConcurrencyStability_001"
+name: "多线程场景线程安全设计缺失"
+category: "并发稳定性"
+severity: "HIGH"
+language: ["cpp", "c++"]
+author: "OH-Department7 Stability Team"
+---
+
+# 多线程场景线程安全设计缺失
+
+## 问题描述
+
+在多线程场景下，共享数据的访问如果没有做好线程安全设计，会导致数据竞争、内存不一致等问题，引发程序崩溃、数据损坏等严重稳定性问题。必须合理使用锁或其他同步机制保护共享数据。
+
+## 检测示例
+
+### ❌ 问题代码
+
+```cpp
+// 错误示例1：全局变量无锁保护
+int g_counter = 0;
+
+void IncrementCounter()
+{
+    g_counter++;  // 危险：多线程并发访问导致数据竞争
+}
+
+// 错误示例2：成员变量无锁保护
+class SharedQueue {
+public:
+    void Push(int value) {
+        queue_.push_back(value);  // 危险：无锁保护的并发写入
+    }
+    
+    int Pop() {
+        int value = queue_.front();  // 危险：无锁保护的并发读取
+        queue_.pop_front();
+        return value;
+    }
+    
+private:
+    std::deque<int> queue_;  // 多线程共享队列
+};
+
+// 错误示例3：单例模式无锁保护
+class Singleton {
+public:
+    static Singleton* GetInstance() {
+        if (instance_ == nullptr) {  // 危险：竞态条件
+            instance_ = new Singleton();
+        }
+        return instance_;
+    }
+    
+private:
+    static Singleton* instance_;
+};
+
+// 错误示例4：引用计数无锁保护
+class RefCounted {
+public:
+    void AddRef() {
+        refCount_++;  // 危险：无锁保护的引用计数增加
+    }
+    
+    void Release() {
+        if (--refCount_ == 0) {  // 危险：无锁保护的引用计数减少和判断
+            delete this;
+        }
+    }
+    
+private:
+    int refCount_ = 1;
+};
+
+// 错误示例5：检查-执行模式无锁保护
+std::map<int, std::string> g_cache;
+std::mutex g_mutex;
+
+std::string GetValue(int key) {
+    auto it = g_cache.find(key);  // 危险：在锁外访问共享数据
+    if (it != g_cache.end()) {
+        return it->second;
+    }
+    
+    std::lock_guard<std::mutex> lock(g_mutex);
+    g_cache[key] = LoadFromDisk(key);
+    return g_cache[key];
+}
+```
+
+### ✅ 修复方案
+
+```cpp
+// 正确示例1：使用std::mutex保护全局变量
+#include <mutex>
+
+int g_counter = 0;
+std::mutex g_counterMutex;
+
+void IncrementCounter()
+{
+    std::lock_guard<std::mutex> lock(g_counterMutex);
+    g_counter++;  // 安全：有锁保护
+}
+
+// 正确示例2：使用线程安全队列
+class SharedQueue {
+public:
+    void Push(int value) {
+        std::lock_guard<std::mutex> lock(mutex_);
+        queue_.push_back(value);
+    }
+    
+    int Pop() {
+        std::lock_guard<std::mutex> lock(mutex_);
+        if (queue_.empty()) {
+            return -1;  // 返回错误码表示队列为空
+        }
+        int value = queue_.front();
+        queue_.pop_front();
+        return value;
+    }
+    
+private:
+    std::deque<int> queue_;
+    std::mutex mutex_;
+};
+
+// 正确示例3：使用std::call_once实现线程安全单例
+class Singleton {
+public:
+    static Singleton* GetInstance() {
+        std::call_once(initFlag_, []() {
+            instance_ = new Singleton();
+        });
+        return instance_;
+    }
+    
+private:
+    static Singleton* instance_;
+    static std::once_flag initFlag_;
+};
+
+// 正确示例4：使用std::atomic实现引用计数
+class RefCounted {
+public:
+    void AddRef() {
+        refCount_.fetch_add(1, std::memory_order_relaxed);
+    }
+    
+    void Release() {
+        if (refCount_.fetch_sub(1, std::memory_order_acq_rel) == 1) {
+            delete this;
+        }
+    }
+    
+private:
+    std::atomic<int> refCount_{1};
+};
+
+// 正确示例5：完整的锁保护
+std::map<int, std::string> g_cache;
+std::mutex g_mutex;
+
+std::string GetValue(int key) {
+    {
+        std::lock_guard<std::mutex> lock(g_mutex);
+        auto it = g_cache.find(key);
+        if (it != g_cache.end()) {
+            return it->second;
+        }
+    }
+    
+    std::string value = LoadFromDisk(key);
+    
+    std::lock_guard<std::mutex> lock(g_mutex);
+    g_cache[key] = value;
+    return value;
+}
+
+// 正确示例6：使用读写锁优化读多写少场景
+#include <shared_mutex>
+
+class ThreadSafeCache {
+public:
+    std::string Get(int key) {
+        std::shared_lock<std::shared_mutex> lock(rwMutex_);
+        auto it = cache_.find(key);
+        if (it != cache_.end()) {
+            return it->second;
+        }
+        return "";
+    }
+    
+    void Set(int key, const std::string& value) {
+        std::unique_lock<std::shared_mutex> lock(rwMutex_);
+        cache_[key] = value;
+    }
+    
+private:
+    std::map<int, std::string> cache_;
+    mutable std::shared_mutex rwMutex_;
+};
+
+// 正确示例7：使用thread_local避免同步开销
+thread_local int t_threadCounter = 0;
+
+void ProcessInThread()
+{
+    t_threadCounter++;  // 安全：thread_local，每个线程独立计数，无需同步
+    DoWork();
+}
+
+// 正确示例8：精确的memory_order控制
+std::atomic<bool> dataReady_{false};
+std::atomic<int> sharedData_{0};
+
+void Producer()
+{
+    sharedData_.store(42, std::memory_order_relaxed);  // 数据写入
+    dataReady_.store(true, std::memory_order_release);  // release标记数据已准备好
+}
+
+void Consumer()
+{
+    while (!dataReady_.load(std::memory_order_acquire)) {  // acquire等待数据就绪
+        std::this_thread::yield();
+    }
+    int data = sharedData_.load(std::memory_order_relaxed);  // 安全：release-acquire同步
+}
+
+// 正确示例9：使用atomic_store_explicit/load_explicit
+std::atomic<std::shared_ptr<NodeList>> childrenList_;
+
+void UpdateChildren(std::shared_ptr<NodeList> newList)
+{
+    std::atomic_store_explicit(&childrenList_, newList, std::memory_order_release);
+}
+
+std::shared_ptr<NodeList> GetChildren() const
+{
+    return std::atomic_load_explicit(&childrenList_, std::memory_order_acquire);
+}
+```
+
+## 检测范围
+
+检查以下多线程场景：
+
+1. 全局变量在多线程环境下的访问
+2. 类成员变量在多线程环境下的访问
+3. 单例模式的初始化
+4. 引用计数的增减操作
+5. 共享容器的并发访问
+6. 检查-执行（check-then-act）模式
+
+## 检测要点
+
+1. 识别共享数据：全局变量、静态变量、类成员变量
+2. 识别并发场景：线程函数、回调、异步任务
+3. 检查是否有同步机制：mutex、lock_guard、atomic、condition_variable
+4. 检查锁的粒度和正确性
+5. 排除NOPROTECT标记的代码
+
+### memory_order使用说明
+
+精确的内存序控制可以提高性能并确保正确的同步：
+
+- **memory_order_relaxed**：仅保证原子性，无顺序约束
+  - 适用场景：纯统计计数、不需要同步的数据
+  - 示例：`counter.fetch_add(1, std::memory_order_relaxed)`
+
+- **memory_order_release**：写操作，确保之前的写操作对其他线程可见
+  - 适用场景：发布数据、状态标记
+  - 示例：`dataReady_.store(true, std::memory_order_release)`
+
+- **memory_order_acquire**：读操作，确保看到release之前的所有写操作
+  - 适用场景：消费数据、等待状态
+  - 示例：`while (!dataReady_.load(std::memory_order_acquire))`
+
+- **memory_order_acq_rel**：同时具有release和acquire语义
+  - 适用场景：读-修改-写操作（如fetch_sub）
+  - 示例：`refCount_.fetch_sub(1, std::memory_order_acq_rel)`
+
+- **atomic_store_explicit/atomic_load_explicit**：更明确的原子操作
+  - 适用场景：std::atomic<std::shared_ptr> 等复杂类型
+  - 示例：`std::atomic_store_explicit(&childrenList_, newList, std::memory_order_release)`
+
+### thread_local最佳实践
+
+thread_local 用于性能优化，避免多线程同步开销：
+
+- **适用场景**：
+  - 线程独立的计数器/统计数据
+  - 线程独立的状态缓存
+  - 性能关键路径的临时数据
+
+- **优势**：
+  - 每个线程独立存储，无需锁保护
+  - 访问速度与普通变量相同
+  - 自动管理生命周期
+
+- **限制**：
+  - 不能用于需要跨线程共享的数据
+  - 注意线程销毁时的数据清理
+
+### 全局变量分类处理
+
+根据用途选择不同的保护策略：
+
+- **统计计数器**：使用 `std::atomic` + `memory_order_relaxed`
+- **缓存数据**：使用 `std::mutex` 保护或读写锁
+- **配置数据**：使用 `std::call_once` 初始化，只读访问
+- **线程独立数据**：使用 `thread_local`，无需同步
+
+## 风险流分析（RiskFlow）
+
+- **RISK_SOURCE**: 多线程环境下的共享数据访问
+- **RISK_TYPE**: 数据竞争、竞态条件
+- **RISK_PATH**: 共享数据 -> 无锁保护 -> 并发访问 -> 数据不一致/崩溃
+- **IMPACT_POINT**: 数据损坏、程序崩溃、死锁、活锁
+
+## 影响分析（ImpactAnalysis）
+
+- **Trigger**: 多线程并发访问同一共享数据
+- **Propagation**: 竞态条件导致数据不一致、内存错误
+- **Consequence**: 数据损坏、程序崩溃、安全漏洞
+- **Mitigation**: 使用mutex、atomic等同步机制保护共享数据
+
+## 误报排除
+
+| 场景 | 识别特征 | 处理方式 |
+|------|----------|----------|
+| NOPROTECT 标记 | 有 // NOPROTECT 注释 | 不报 |
+| 已有锁保护 | 存在 lock_guard、unique_lock 等 | 不报 |
+| 已使用 atomic | 变量类型为 std::atomic | 不报 |
+| 线程局部存储 | thread_local 关键字 | 不报 |
+| 只读数据 | constexpr、const 且无写入 | 不报 |
+| 单线程场景 | 明确注释说明单线程 | 不报 |
+## 测试用例
+
+### 触发用例（应该报）
+
+```cpp
+// test_ConcurrencyStability_001_trigger.cpp
+int g_counter = 0;
+
+void trigger_bad_1()
+{
+    g_counter++;  // 应该报：全局变量无锁保护
+}
+
+class UnsafeQueue {
+public:
+    void Push(int value) {
+        queue_.push_back(value);  // 应该报：成员变量无锁保护
+    }
+private:
+    std::deque<int> queue_;
+};
+
+class Singleton {
+public:
+    static Singleton* GetInstance() {
+        if (instance_ == nullptr) {  // 应该报：单例模式竞态条件
+            instance_ = new Singleton();
+        }
+        return instance_;
+    }
+private:
+    static Singleton* instance_;
+};
+```
+
+### 安全用例（不应该报）
+
+```cpp
+// test_ConcurrencyStability_001_safe.cpp
+int g_counter = 0;
+std::mutex g_mutex;
+
+void safe_good_1()
+{
+    std::lock_guard<std::mutex> lock(g_mutex);
+    g_counter++;  // 安全：有锁保护
+}
+
+class SafeQueue {
+public:
+    void Push(int value) {
+        std::lock_guard<std::mutex> lock(mutex_);
+        queue_.push_back(value);  // 安全：有锁保护
+    }
+private:
+    std::deque<int> queue_;
+    std::mutex mutex_;
+};
+
+std::atomic<int> g_atomicCounter(0);
+
+void safe_good_2()
+{
+    g_atomicCounter++;  // 安全：使用atomic
+}
+
+// NOPROTECT: 单线程场景
+int g_singleThread = 0;
+void noprotect_case()
+{
+    g_singleThread++;  // 不报：明确标记单线程
+}
+```