@ohos-graphics/stability-code-review 0.1.0

package/references/ConcurrencyStability/StabilityCodeReview_ConcurrencyStability_002.md

@@ -0,0 +1,335 @@
+---
+rule_id: "StabilityCodeReview_ConcurrencyStability_002"
+name: "智能指针线程安全问题"
+category: "并发稳定性"
+severity: "HIGH"
+language: ["cpp", "c++"]
+author: "OH-Department7 Stability Team"
+---
+
+# 智能指针线程安全问题
+
+## 问题描述
+
+智能指针(shared_ptr/sptr)不是线程安全的。对于同一个shared_ptr或sptr对象，允许多线程同时读，但是不允许多线程又读又写。如果多个线程同时对同一个智能指针对象进行写操作（赋值、reset、swap等），会导致引用计数竞争，引发内存泄漏、悬空指针等问题。
+
+## 检测示例
+
+### ❌ 问题代码
+
+```cpp
+// 错误示例1：多线程并发修改同一个shared_ptr
+std::shared_ptr<Data> g_data;
+
+void ThreadA()
+{
+    g_data = std::make_shared<Data>();  // 危险：多线程并发赋值
+}
+
+void ThreadB()
+{
+    g_data = std::make_shared<Data>();  // 危险：多线程并发赋值
+}
+
+// 错误示例2：多线程并发reset
+std::shared_ptr<Resource> g_resource;
+
+void ReleaseResource()
+{
+    g_resource.reset();  // 危险：多线程并发reset
+}
+
+void UpdateResource()
+{
+    g_resource.reset(new Resource());  // 危险：多线程并发reset
+}
+
+// 错误示例3：多线程并发swap
+std::shared_ptr<Buffer> g_buffer;
+
+void SwapBuffer(std::shared_ptr<Buffer> newBuffer)
+{
+    g_buffer.swap(newBuffer);  // 危险：多线程并发swap
+}
+
+// 错误示例4：sptr对象多线程写入
+using namespace OHOS;
+sptr<Service> g_service;
+
+void UpdateService(sptr<Service> service)
+{
+    g_service = service;  // 危险：多线程并发写入sptr
+}
+
+// 错误示例5：回调中修改shared_ptr
+class Handler {
+public:
+    std::shared_ptr<Context> context_;
+    
+    void OnCallback() {
+        context_ = std::make_shared<Context>();  // 危险：回调可能并发执行
+    }
+};
+```
+
+### ✅ 修复方案
+
+```cpp
+// 正确示例1：使用mutex保护shared_ptr写操作
+std::shared_ptr<Data> g_data;
+std::mutex g_dataMutex;
+
+void ThreadA()
+{
+    std::lock_guard<std::mutex> lock(g_dataMutex);
+    g_data = std::make_shared<Data>();  // 安全：有锁保护
+}
+
+void ThreadB()
+{
+    std::lock_guard<std::mutex> lock(g_dataMutex);
+    g_data = std::make_shared<Data>();  // 安全：有锁保护
+}
+
+// 正确示例2：使用atomic<shared_ptr> (C++20)
+std::atomic<std::shared_ptr<Data>> g_atomicData;
+
+void ThreadA()
+{
+    g_atomicData.store(std::make_shared<Data>());  // 安全：atomic操作
+}
+
+void ThreadB()
+{
+    auto data = g_atomicData.load();  // 安全：atomic操作
+}
+
+// 正确示例3：返回shared_ptr副本而非修改全局变量
+std::shared_ptr<Resource> GetResource()
+{
+    std::lock_guard<std::mutex> lock(g_resourceMutex);
+    return g_resource;  // 安全：返回副本，引用计数原子增加
+}
+
+// 正确示例4：使用call_once初始化
+std::shared_ptr<Service> g_service;
+std::once_flag g_serviceFlag;
+
+void InitService()
+{
+    std::call_once(g_serviceFlag, []() {
+        g_service = std::make_shared<Service>();
+    });
+}
+
+// 正确示例5：只读场景无需锁保护
+std::shared_ptr<const Config> g_config;
+
+void ReadConfig()
+{
+    auto config = g_config;  // 安全：多线程同时读是允许的
+    if (config) {
+        config->GetValue();
+    }
+}
+
+// 正确示例6：每个线程持有独立副本
+class ThreadSafeHandler {
+public:
+    void Process() {
+        auto localContext = context_;  // 创建副本
+        localContext->DoWork();  // 安全：使用局部副本
+    }
+private:
+    std::shared_ptr<Context> context_;
+};
+
+// 正确示例7：使用weak_ptr安全访问可能已销毁的对象
+class RSRenderNodeDrawable {
+public:
+    inline std::shared_ptr<const RSRenderNode> GetRenderNode()
+    {
+        return renderNode_.lock();  // 安全：weak_ptr::lock()是线程安全的原子操作
+    }
+    
+    void Draw() {
+        auto node = renderNode_.lock();  // 创建shared_ptr副本
+        if (!node) {
+            return;  // 对象已销毁，安全退出
+        }
+        node->Process();  // 安全：使用局部副本，避免并发问题
+    }
+private:
+    std::weak_ptr<const RSRenderNode> renderNode_;  // 使用weak_ptr避免循环引用
+};
+
+// 正确示例8：渲染树中的父子节点引用管理
+class RSRenderNode {
+public:
+    void RemoveExpiredChildren() {
+        children_.remove_if([&](const auto& child) -> bool {
+            auto existingChild = child.lock();  // 线程安全的lock()操作
+            if (existingChild == nullptr) {
+                return true;  // 移除已过期节点
+            }
+            // 使用existingChild进行操作
+            return false;
+        });
+    }
+private:
+    std::list<std::weak_ptr<RSRenderNode>> children_;  // 使用weak_ptr存储子节点
+    std::weak_ptr<RSRenderNode> parent_;  // 使用weak_ptr存储父节点引用
+};
+```
+
+## 检测范围
+
+检查以下智能指针并发场景：
+
+1. 全局shared_ptr/sptr对象的写操作
+2. 成员shared_ptr在多线程环境下的写操作
+3. shared_ptr的reset、swap操作
+4. 回调/异步任务中修改shared_ptr
+5. shared_ptr的赋值操作
+
+## 检测要点
+
+1. 识别shared_ptr/sptr变量
+2. 识别写操作：赋值、reset、swap、move
+3. 检查多线程上下文：线程函数、回调、异步任务
+4. 检查是否有mutex保护
+5. 区分读操作（安全）和写操作（需保护）
+
+### weak_ptr线程安全特性
+
+weak_ptr是线程安全的，常用于避免循环引用和安全访问可能已销毁的对象：
+
+- **weak_ptr::lock()操作是原子且线程安全的**
+  - 返回一个shared_ptr，如果对象还存在则引用计数原子增加
+  - 如果对象已销毁则返回nullptr
+  - 无需额外锁保护
+
+- **适用场景**：
+  - 渲染树中的父子节点引用（避免循环引用）
+  - 观察者模式中观察对象的引用
+  - 缓存中对象的弱引用
+
+- **典型用法**：
+  ```cpp
+  // 线程安全的访问
+  auto node = weakNode_.lock();
+  if (!node) return;  // 对象已销毁
+  node->Process();  // 使用局部副本，避免并发问题
+  ```
+
+### 智能指针操作分类
+
+- **读操作（线程安全）**：
+  - `get()`：获取裸指针
+  - `use_count()`：获取引用计数
+  - `operator bool()`：检查是否有效
+  - `weak_ptr::lock()`：尝试获取shared_ptr
+
+- **写操作（需要保护）**：
+  - `operator=`：赋值操作
+  - `reset()`：重置指针
+  - `swap()`：交换指针
+  - `operator*()`解引用后的修改操作
+
+### 参数传递的线程安全
+
+智能指针作为参数传递时引用计数原子增加，是线程安全的：
+
+```cpp
+// 参数传递，引用计数原子增加
+void ProcessNode(std::shared_ptr<Node> node) {
+    node->DoWork();  // 安全：参数传递时已增加引用计数
+}
+
+// 调用时
+ProcessNode(globalNode);  // 安全：传递过程中引用计数原子增加
+```
+
+## 风险流分析（RiskFlow）
+
+- **RISK_SOURCE**: 智能指针对象在多线程环境下被并发写
+- **RISK_TYPE**: 引用计数竞争、数据竞争
+- **RISK_PATH**: 并发写操作 -> 引用计数更新冲突 -> 内存管理错误
+- **IMPACT_POINT**: 内存泄漏、悬空指针、程序崩溃
+
+## 影响分析（ImpactAnalysis）
+
+- **Trigger**: 多线程同时对同一智能指针执行写操作
+- **Propagation**: 引用计数更新不同步导致计数错误
+- **Consequence**: 内存泄漏、悬空指针访问、程序崩溃
+- **Mitigation**: 使用mutex保护写操作，或使用atomic<shared_ptr>
+
+## 误报排除
+
+| 场景 | 识别特征 | 处理方式 |
+|------|----------|----------|
+| NOPROTECT 标记 | 有 // NOPROTECT 注释 | 不报 |
+| 已有锁保护 | 存在 lock_guard、unique_lock 等 | 不报 |
+| 只读操作 | 仅使用 get、use_count 等 | 不报 |
+| 创建副本 | 返回 shared_ptr 副本 | 不报 |
+| atomic智能指针 | std::atomic<shared_ptr> | 不报 |
+| 单线程场景 | 明确注释说明单线程 | 不报 |
+## 测试用例
+
+### 触发用例（应该报）
+
+```cpp
+std::shared_ptr<Data> g_data;
+
+void trigger_bad_1()
+{
+    g_data = std::make_shared<Data>();  // 应该报：无锁保护的写操作
+}
+
+void trigger_bad_2()
+{
+    g_data.reset();  // 应该报：无锁保护的reset
+}
+
+void trigger_bad_3()
+{
+    g_data.swap(other);  // 应该报：无锁保护的swap
+}
+
+sptr<Service> g_service;
+void trigger_bad_4()
+{
+    g_service = new Service();  // 应该报：sptr无锁写操作
+}
+```
+
+### 安全用例（不应该报）
+
+```cpp
+std::shared_ptr<Data> g_data;
+std::mutex g_mutex;
+
+void safe_good_1()
+{
+    std::lock_guard<std::mutex> lock(g_mutex);
+    g_data = std::make_shared<Data>();  // 安全：有锁保护
+}
+
+void safe_good_2()
+{
+    auto data = g_data;  // 安全：只读操作（副本）
+}
+
+void safe_good_3()
+{
+    if (g_data) {  // 安全：只读检查
+        g_data->GetValue();
+    }
+}
+
+// NOPROTECT: 单线程初始化
+void noprotect_init()
+{
+    g_data = std::make_shared<Data>();  // 不报：明确标记单线程
+}
+```

package/references/ConcurrencyStability/StabilityCodeReview_ConcurrencyStability_003.md

@@ -0,0 +1,284 @@
+---
+rule_id: "StabilityCodeReview_ConcurrencyStability_003"
+name: "std::atomic时序问题"
+category: "并发稳定性"
+severity: "MEDIUM"
+language: ["cpp", "c++"]
+author: "OH-Department7 Stability Team"
+---
+
+# std::atomic时序问题
+
+## 问题描述
+
+std::atomic可以保证操作的原子性，但是不能保证时序。使用std::atomic需要检验代码的时序是否正确。特别是使用memory_order_relaxed时，编译器和CPU可能对操作进行重排，导致数据可见性问题。对于同步标志，必须使用合适的内存序（acquire/release或seq_cst）保证时序正确。
+
+## 检测示例
+
+### ❌ 问题代码
+
+```cpp
+// 错误示例1：使用relaxed内存序作为同步标志
+std::atomic<bool> g_ready{false};
+std::atomic<int> g_data{0};
+
+void Producer()
+{
+    g_data.store(42, std::memory_order_relaxed);
+    g_ready.store(true, std::memory_order_relaxed);  // 危险：relaxed无法保证时序
+}
+
+void Consumer()
+{
+    while (!g_ready.load(std::memory_order_relaxed)) {  // 危险：可能看到ready但看不到data
+        ;
+    }
+    int value = g_data.load(std::memory_order_relaxed);  // 危险：可能读到旧值
+}
+
+// 错误示例2：检查-执行模式的时序问题
+std::atomic<bool> g_flag{false};
+
+void ThreadA()
+{
+    // 设置数据
+    data_ = 42;
+    g_flag.store(true, std::memory_order_relaxed);  // 危险：数据设置可能被重排到flag之后
+}
+
+void ThreadB()
+{
+    if (g_flag.load(std::memory_order_relaxed)) {  // 危险：可能看到flag但数据未准备好
+        useData(data_);  // 危险：可能使用未准备好的数据
+    }
+}
+
+// 错误示例3：多标志同步问题
+std::atomic<bool> g_flag1{false};
+std::atomic<bool> g_flag2{false};
+
+void SetFlags()
+{
+    g_flag1.store(true, std::memory_order_relaxed);
+    g_flag2.store(true, std::memory_order_relaxed);  // 危险：两个标志的顺序无法保证
+}
+
+void CheckFlags()
+{
+    if (g_flag2.load(std::memory_order_relaxed) && 
+        !g_flag1.load(std::memory_order_relaxed)) {  // 危险：可能看到flag2但看不到flag1
+        // 异常状态
+    }
+}
+
+// 错误示例4：发布-订阅模式的时序问题
+std::atomic<Object*> g_object{nullptr};
+
+void PublishObject()
+{
+    Object* obj = new Object();
+    obj->Init();
+    g_object.store(obj, std::memory_order_relaxed);  // 危险：Init可能被重排到store之后
+}
+
+void SubscribeObject()
+{
+    Object* obj = g_object.load(std::memory_order_relaxed);
+    if (obj) {
+        obj->Use();  // 危险：可能使用未完成初始化的对象
+    }
+}
+
+// 错误示例5：引用计数发布的时序问题
+std::atomic<int> g_refCount{0};
+std::atomic<bool> g_initialized{false};
+
+void InitAndPublish()
+{
+    g_refCount.store(1, std::memory_order_relaxed);
+    DoInitialization();
+    g_initialized.store(true, std::memory_order_relaxed);  // 危险：时序无法保证
+}
+```
+
+### ✅ 修复方案
+
+```cpp
+// 正确示例1：使用release/acquire保证时序
+std::atomic<bool> g_ready{false};
+std::atomic<int> g_data{0};
+
+void Producer()
+{
+    g_data.store(42, std::memory_order_relaxed);
+    g_ready.store(true, std::memory_order_release);  // 安全：release保证之前的操作可见
+}
+
+void Consumer()
+{
+    while (!g_ready.load(std::memory_order_acquire)) {  // 安全：acquire保证之后的操作看到release前的状态
+        ;
+    }
+    int value = g_data.load(std::memory_order_relaxed);  // 安全：此时数据一定可见
+}
+
+// 正确示例2：使用seq_cst内存序
+std::atomic<bool> g_flag{false};
+
+void ThreadA()
+{
+    data_ = 42;
+    g_flag.store(true, std::memory_order_seq_cst);  // 安全：seq_cst保证全局顺序
+}
+
+void ThreadB()
+{
+    if (g_flag.load(std::memory_order_seq_cst)) {
+        useData(data_);  // 安全：数据一定准备好
+    }
+}
+
+// 正确示例3：使用mutex替代复杂同步
+std::mutex g_mutex;
+bool g_flag1 = false;
+bool g_flag2 = false;
+
+void SetFlags()
+{
+    std::lock_guard<std::mutex> lock(g_mutex);
+    g_flag1 = true;
+    g_flag2 = true;  // 安全：mutex保证顺序
+}
+
+// 正确示例4：发布时使用release
+std::atomic<Object*> g_object{nullptr};
+
+void PublishObject()
+{
+    Object* obj = new Object();
+    obj->Init();
+    g_object.store(obj, std::memory_order_release);  // 安全：Init一定在store之前完成
+}
+
+void SubscribeObject()
+{
+    Object* obj = g_object.load(std::memory_order_acquire);
+    if (obj) {
+        obj->Use();  // 安全：Init一定已完成
+    }
+}
+
+// 正确示例5：一次性初始化使用call_once
+std::once_flag g_initFlag;
+Object* g_object = nullptr;
+
+void InitObject()
+{
+    std::call_once(g_initFlag, []() {
+        g_object = new Object();
+        g_object->Init();
+    });
+}
+```
+
+## 检测范围
+
+检查以下atomic时序场景：
+
+1. atomic变量作为同步标志的使用
+2. memory_order_relaxed用于同步
+3. 检查-执行（check-then-act）模式
+4. 发布-订阅模式
+5. 多atomic变量的顺序依赖
+
+## 检测要点
+
+1. 识别std::atomic变量
+2. 检测memory_order_relaxed使用
+3. 分析同步标志的使用场景
+4. 检查检查-执行模式
+5. 验证发布操作的内存序
+
+## 风险流分析（RiskFlow）
+
+- **RISK_SOURCE**: atomic变量使用不正确的内存序
+- **RISK_TYPE**: 时序问题、可见性问题
+- **RISK_PATH**: relaxed内存序 -> 操作重排 -> 数据可见性问题 -> 状态不一致
+- **IMPACT_POINT**: 逻辑错误、状态异常、程序崩溃
+
+## 影响分析（ImpactAnalysis）
+
+- **Trigger**: 一个线程设置标志后另一个线程读取到旧值
+- **Propagation**: 内存序不正确导致编译器/CPU重排操作
+- **Consequence**: 状态标志失效、逻辑错误、程序异常行为
+- **Mitigation**: 对于同步标志使用acquire/release或seq_cst内存序
+
+## 误报排除
+
+| 场景 | 识别特征 | 处理方式 |
+|------|----------|----------|
+| NOPROTECT 标记 | 有 // NOPROTECT 注释 | 不报 |
+| 纯计数场景 | 仅用于计数，不用于同步 | 不报 |
+| 使用release/acquire | 正确的内存序 | 不报 |
+| 使用seq_cst | 默认内存序 | 不报 |
+| 单线程场景 | 明确注释说明单线程 | 不报 |
+## 测试用例
+
+### 触发用例（应该报）
+
+```cpp
+std::atomic<bool> g_ready{false};
+std::atomic<int> g_data{0};
+
+void trigger_bad_1()
+{
+    g_data.store(42, std::memory_order_relaxed);
+    g_ready.store(true, std::memory_order_relaxed);  // 应该报：relaxed用于同步标志
+}
+
+void trigger_bad_2()
+{
+    while (!g_ready.load(std::memory_order_relaxed)) {  // 应该报：relaxed用于同步等待
+        ;
+    }
+}
+
+std::atomic<bool> g_flag{false};
+void trigger_bad_3()
+{
+    if (g_flag.load(std::memory_order_relaxed)) {  // 应该报：检查时序问题
+        useData(data_);
+    }
+}
+```
+
+### 安全用例（不应该报）
+
+```cpp
+std::atomic<bool> g_ready{false};
+std::atomic<int> g_data{0};
+
+void safe_good_1()
+{
+    g_data.store(42, std::memory_order_relaxed);
+    g_ready.store(true, std::memory_order_release);  // 安全：使用release
+}
+
+void safe_good_2()
+{
+    while (!g_ready.load(std::memory_order_acquire)) {  // 安全：使用acquire
+        ;
+    }
+}
+
+void safe_good_3()
+{
+    g_counter.fetch_add(1, std::memory_order_relaxed);  // 安全：纯计数场景
+}
+
+std::atomic<int> g_counter{0};
+void safe_good_4()
+{
+    g_counter++;  // 安全：默认seq_cst
+}
+```