C++ 里 两个独立的所有权域之间没有建立同步的问题

C++ 里 两个独立的所有权域之间没有建立同步的问题

flyfish

下面的代码演示的是一种非常典型的跨线程生命周期错误

两个独立的所有权域之间没有建立同步:

  • 所有权域 A:shared_ptr<ElementWrap> 的控制块,管 ElementWrap 对象本身。
  • 所有权域 B:GObject 的引用计数,管底层 GObject 对象。

线程 A 在域 A 里拿到了一份引用,所以域 A 保证 ElementWrap 对象处于其生命周期内。但线程 A 没有在域 B 里拿引用,所以域 B 不保证底层 GObject 对象处于其生命周期内。当线程 B 在域 B 里把最后一份引用放掉,GObject 就生命周期结束、内存被释放,而线程 A 手里那个 ElementWrap 还活着,它内部的观察指针 inner_ 就悬空了。

修复就是让线程 A 在锁内、在放锁之前,也在域 B 里拿一份引用。这样两个域都保证了对象存活,直到 RAII 守卫在域 B 里把那份引用还回去。

具体场景

  1. 有一个 C++ 类 ElementWrap,内部包了一个 C 库对象(GObject/GStreamer element),用裸指针 inner_ 存着。
  2. 这个 C++ 对象放在一个全局 map 里,用 shared_ptr<ElementWrap> 管理。
  3. 线程 A(业务/用户线程) 在锁内从 map 里 find 到这个对象,拷出一份 shared_ptr<ElementWrap>,然后放锁,准备调它的方法设属性。
  4. 线程 B(停流/清理线程) 同时在做清理:清空 map、销毁底层 pipeline。pipeline 一销毁,它持有的那些 GObject 引用计数归零,内存被真正 free 掉。
  5. 线程 A 拿着还活着的 ElementWrap(因为自己手里那份 shared_ptr 还在)继续调 SetProp,结果函数内部用的 inner_ 已经指向一块被释放的内存。

这是 Use-After-Free(释放后使用),但它的特殊之处在于:

  • 不是忘了 delete,而是 两套生命周期系统对不上。
  • C++ 层用 shared_ptr 管 ElementWrap,GObject 层用 ref/unref 管底层对象。
  • 拷 shared_ptr<ElementWrap> 只让 C++ 壳的引用计数加 1,不会自动让 GObject 的引用计数加 1。
  • 结果就是壳活着、壳里的GObject 已经销毁了。

凡是满足下面三个条件,基本就会复现:

  1. C++ 对象内部持有一个 C 库的裸指针(GObject、GStreamer、libav、sqlite 句柄、文件句柄都算)。
  2. 这个 C++ 对象被多线程访问,一个线程在用,另一个线程在销毁底层资源。
  3. 用 shared_ptr 管理 C++ 对象,但没有在拿到指针的同时给底层 C 对象也加一份引用。
cpp 复制代码
// error_demo.cpp
// 完整错误版本:演示 shared_ptr<ElementWrap> 保活了 C++ 包装壳,
// 但壳内裸指针 inner_ 指向的底层 GObject 已经被 pipeline 释放,
// 导致后续 SetProp 调用触发 UAF。
//
// 编译:g++ -std=c++14 -Wall error_demo.cpp -o error_demo
// 运行:./error_demo

#include <iostream>
#include <memory>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>

// ============================================================
// 模拟 GObject:带引用计数,释放后 alive 标记为 false
// ============================================================

struct MockGob {
    std::string name;
    int refCount;
    bool alive;

    explicit MockGob(std::string n)
        : name(std::move(n)), refCount(1), alive(true)
    {
    }
};

void GobRef(MockGob* o)
{
    if (o == nullptr) return;
    ++o->refCount;
    std::cout << "  [ref   ] " << o->name << " refCount=" << o->refCount << "\n";
}

void GobUnref(MockGob* o)
{
    if (o == nullptr) return;
    --o->refCount;
    std::cout << "  [unref ] " << o->name << " refCount=" << o->refCount << "\n";

    if (o->refCount == 0) {
        o->alive = false;
        std::cout << "  [free  ] " << o->name
            << " 内存已释放(alive=false),此后再用 inner_ 就是 UAF\n";
    }
}

bool GobSetProp(MockGob* o, const std::string& key, const std::string& val)
{
    if (o == nullptr) {
        std::cout << "  [set   ] o == nullptr,无法设置\n";
        return false;
    }
    if (!o->alive || o->refCount <= 0) {
        // 这里就是 UAF 真正发生的地方
        std::cout << "  *** [UAF!] 正在访问已释放的对象 ***\n";
        std::cout << "  *** 对象名: " << o->name << "\n";
        std::cout << "  *** 试图设置: " << key << " = " << val << "\n";
        std::cout << "  *** 当前状态: alive=" << std::boolalpha << o->alive
            << ", refCount=" << o->refCount << "\n";
        std::cout << "  *** 后果: 在真实 GStreamer 里这里会段错误 / 堆损坏\n";
        return false;
    }
    std::cout << "  [set OK] " << o->name << "." << key << " = " << val << "\n";
    return true;
}

// ============================================================
// C++ 包装类:内部持有裸指针 inner_,不 ref 也不 unref
// ============================================================

class ElementWrap {
public:
    ElementWrap(MockGob* inner, std::string factoryName)
        : inner_(inner), factoryName_(std::move(factoryName))
    {
        // [BUG] 构造时只存裸指针,没有 GobRef(inner_)
        std::cout << "[wrap ctor] this=" << this
            << " factory=" << factoryName_
            << " inner=" << inner_ << "\n";
    }

    ~ElementWrap()
    {
        // [BUG] 析构时也没有 GobUnref(inner_)
        std::cout << "[wrap dtor] this=" << this
            << " factory=" << factoryName_ << "\n";
    }

    bool SetProp(const std::string& key, const std::string& val)
    {
        std::cout << "[SetProp ] this=" << this
            << " 用内部 inner_=" << inner_ << "\n";
        return GobSetProp(inner_, key, val);
    }

public:
    MockGob* inner_;          // 裸指针,不拥有底层对象
    std::string factoryName_;
};

// ============================================================
// 模拟 Pipeline / Bin:持有子元件,销毁时 unref 它们
// ============================================================

class MockPipeline {
public:
    explicit MockPipeline(std::string name)
        : self_(new MockGob(std::move(name)))
    {
        std::cout << "[pipe new] " << self_->name
            << " refCount=1(pipeline 自己持有)\n";
    }

    ~MockPipeline() { Destroy(); }

    MockGob* Add(const std::string& childName)
    {
        MockGob* child = new MockGob(childName);
        children_.push_back(child);
        std::cout << "[pipe add] " << child->name
            << " refCount=1(由 pipeline 持有)\n";
        return child;
    }

    void Destroy()
    {
        if (self_ == nullptr) return;

        std::cout << "[pipe del] 开始释放 pipeline 及子元件\n";
        for (MockGob* c : children_) {
            GobUnref(c);   // 子元件 refCount 1->0,真正释放
        }
        children_.clear();

        GobUnref(self_);
        self_ = nullptr;
    }

private:
    MockGob* self_;
    std::vector<MockGob*> children_;
};

// ============================================================
// 主流程:完整复现错误
// ============================================================

int main()
{
    std::cout << "============================================================\n";
    std::cout << "错误版本:shared_ptr 保活了包装壳,但底层 GObject 已被释放\n";
    std::cout << "============================================================\n";

    // 步骤 1:建 pipeline,加一个子元件
    std::cout << "\n--- 步骤 1: 创建 pipeline 并添加子元件 ---\n";
    MockPipeline pipe("pipeline0");
    MockGob* inner = pipe.Add("channel-selector0");

    // 步骤 2:用 shared_ptr 把元件包起来放进 map
    std::cout << "\n--- 步骤 2: 创建 ElementWrap 并放进 elementMap ---\n";
    std::unordered_map<std::string, std::shared_ptr<ElementWrap>> elementMap;
    elementMap["channel-selector0"] =
        std::shared_ptr<ElementWrap>(new ElementWrap(inner, "channel-selector"));

    // 步骤 3:用户线程在锁内从 map 拷出 shared_ptr
    std::cout << "\n--- 步骤 3: 用户线程拷出 shared_ptr<ElementWrap> ---\n";
    std::shared_ptr<ElementWrap> userElem = elementMap["channel-selector0"];
    std::cout << "  userElem.use_count() = " << userElem.use_count() << "\n";
    std::cout << "  此时 GObject refCount = " << inner->refCount
        << "(注意:没有因为拷了 shared_ptr 而增加)\n";

    // 步骤 4:停流线程清空 map,销毁 pipeline
    std::cout << "\n--- 步骤 4: 停流线程清空 elementMap 并销毁 pipeline ---\n";
    elementMap.clear();
    pipe.Destroy();

    // 步骤 5:检查当前状态
    std::cout << "\n--- 步骤 5: 销毁后的状态检查 ---\n";
    std::cout << "  userElem.use_count() = " << userElem.use_count()
        << "(包装壳还活着,shared_ptr 保活成功)\n";
    std::cout << "  inner->alive = " << std::boolalpha << inner->alive
        << "(底层 GObject 已被释放)\n";
    std::cout << "  userElem->inner_ = " << userElem->inner_
        << "(指针值还在,但指向的内存已死)\n";

    // 步骤 6:用户线程继续用包装壳调属性设置 -> UAF
    std::cout << "\n--- 步骤 6: 用户线程继续调 SetProp,触发 UAF ---\n";
    bool ok = userElem->SetProp("channelIds", "9");

    // 步骤 7:结论
    std::cout << "\n============================================================\n";
    std::cout << "结论\n";
    std::cout << "============================================================\n";
    std::cout << "SetProp 返回值 = " << std::boolalpha << ok << "\n";
    std::cout << "错误根因:\n";
    std::cout << "  ElementWrap 构造函数只存裸指针 inner_,没有 GobRef(inner_)。\n";
    std::cout << "  所以 shared_ptr<ElementWrap> 只保活了 C++ 包装壳,\n";
    std::cout << "  没有保活壳里那个 GObject。\n";
    std::cout << "  pipeline 销毁时 GObject refCount 归零被释放,\n";
    std::cout << "  用户线程拿着还活着的壳继续调 SetProp,访问已释放内存。\n";

    return 0;
}

整体结构

cpp 复制代码
struct MockGob {
    std::string name;
    int refCount;
    bool alive;

    explicit MockGob(std::string n)
        : name(std::move(n)), refCount(1), alive(true)
    {
    }
};

这是一个 C++ 结构体,用来模拟 GStreamer 里的 GObject。它一共三个字段、一个构造函数。我一个一个说。

第一个字段:std::string name;

cpp 复制代码
std::string name;

这是这个对象的名字,比如 "channel-selector0"、"pipeline0"。

它纯粹是为了打印日志用的。你看后面 GobRef、GobUnref 这些函数里打印的都是 o->name,这样你能从输出里看出来到底是哪个元件被 ref 了、哪个被 unref 了。它不参与任何逻辑判断,只是个标签。

第二个字段:int refCount;(重点)

cpp 复制代码
int refCount;

这个字段是整个 demo 的核心,它叫引用计数(reference count)。

它表示什么呢?它表示当前有多少个"使用者"还指着这个对象,不肯放它走。

可以把它理解成一个门口的计数器。每有一个新的人说"我还要用这个对象",计数器加 1;每有一个人说"我用完了,不要了",计数器减 1。当计数器降到 0 的时候,说明没有任何人再需要这个对象了,它就可以被扔掉。

对应到代码里:

  • GobRef(o) 做的事情就是 ++o->refCount,表示"又多一个人要用"。
  • GobUnref(o) 做的事情就是 --o->refCount,表示"又有一个人用完了"。
  • 当 --o->refCount 之后变成 0,就说明所有人都用完了,对象可以释放。

举个具体的数字流转。一开始 pipeline 创建一个子元件:

cpp 复制代码
MockGob* child = new MockGob(childName);

构造函数里 refCount(1),意思是刚创建出来,pipeline 自己算第一个使用者,计数器是 1。

后来用户线程在锁内调了 GobRef(guarded),计数器从 1 变成 2。意思是现在有两个人在用:pipeline 一份,用户线程一份。

再后来 pipeline 销毁,调 GobUnref(child),计数器从 2 变成 1。意思是 pipeline 那份用完了,但用户线程那份还在,所以对象还不能死。

最后用户线程用完了,RAII 守卫析构调 GobUnref,计数器从 1 变成 0。这时候才真正释放。

这就是引用计数的工作方式:它不是一次性决定生死的,而是每个人手里拿一份,每交回一份就减 1,减到 0 才死。

为什么需要这个机制?因为 GStreamer 的对象是跨模块、跨线程共享的。pipeline 持有一份,用户线程持有一份,可能还有别的插件也持有一份。谁也不知道别人什么时候用完,所以用一个计数器来数,所有人都交回了才释放。

第三个字段:bool alive;

cpp 复制代码
bool alive;

这个字段表示这个对象当前是不是"活的"。

它是这个 demo 专门加的。为什么需要它?

在真实的 GStreamer 里,当 refCount 降到 0,对象的内存会被 free() 掉。这时候你再去访问那块内存,操作系统会直接给你一个段错误(segmentation fault),程序整个崩掉。

但我们这个 demo 是要稳定地、可重复地演示 UAF 这个过程。如果真 free 掉内存,每次运行的崩溃行为可能不一样,有时候甚至因为内存没被复用而"看起来正常",教学效果就差了。

所以我们用 alive 这个布尔值来模拟 对象已被释放这个状态。当 refCount 到 0 的时候,我们不真的 free 内存,只是把 alive 设成 false:

cpp 复制代码
if (o->refCount == 0) {
    o->alive = false;   // 模拟释放,不真 free
}

然后后面 GobSetProp 访问对象之前先检查一下:

cpp 复制代码
if (!o->alive || o->refCount <= 0) {
    std::cout << "*** [UAF!] ...";
    return false;
}

如果 alive 是 false,说明这个对象已经"死了",你再访问就是 UAF。这样输出是稳定的,每次跑都能清楚地看到错误发生。

在真实 GStreamer 里,你不需要这个 alive 字段,因为内存 free 掉之后,那块地址就不归这个对象管了,访问就直接崩。alive 只是 demo 为了教学加的一个"模拟开关"。

构造函数

cpp 复制代码
explicit MockGob(std::string n)
    : name(std::move(n)), refCount(1), alive(true)
{
}

这是这个结构体的构造函数,在 new MockGob("channel-selector0") 的时候自动调用。

参数 std::string n

传进来的是对象的名字,比如 "channel-selector0"。

初始化列表

cpp 复制代码
: name(std::move(n)), refCount(1), alive(true)

冒号后面这一段叫成员初始化列表,用来在构造函数体执行之前,给三个字段赋初始值。它做了三件事:

  • name(std::move(n)):把传进来的字符串 n 移动给 name 字段。用 std::move 是避免拷贝整个字符串。
  • refCount(1):引用计数初始化为 1。意思是对象刚创建,创建者(也就是 pipeline)自己算第一个持有者。
  • alive(true):对象刚创建,肯定是活着的。

explicit 关键字

cpp 复制代码
explicit MockGob(std::string n)

explicit 的意思是禁止隐式类型转换。它在这里的作用是防止这种写法偷偷发生:

cpp 复制代码
MockGob o = std::string("hello");   // 没有 explicit 的话,这行能编译过

加了 explicit 之后,上面这种"用一个字符串自动构造一个 MockGob"的隐式转换就被禁止了,你必须显式地写:

cpp 复制代码
MockGob o(std::string("hello"));

这是一个工程习惯,避免构造函数被编译器偷偷用来做意外的类型转换。在这个 demo 里它不影响逻辑,只是个规范。

一个 MockGob 对象在它的整个生命周期里,这三个字段是这样变化的:

  1. new 的时候:name="channel-selector0",refCount=1,alive=true。
  2. 别人 GobRef:refCount 加 1,name 和 alive 不变。
  3. 别人 GobUnref:refCount 减 1。如果减到 0,alive 变成 false。
  4. 在 alive=true 期间访问它,正常工作。
  5. 在 alive=false 之后还访问它,就是 UAF。

name 是标签,refCount 是门口计数器数着还有几个人没走,alive 是这个对象是不是还活着的开关。

<unordered_map>:提供哈希表,就是 key 查 value 的字典。

<utility>:提供 std::move,用来做移动语义。

ElementWrap 类

复制代码
class ElementWrap {
public:
    ElementWrap(MockGob* inner, std::string factoryName)
        : inner_(inner), factoryName_(std::move(factoryName))
    {
        std::cout << "[wrap ctor] this=" << this
                  << " factory=" << factoryName_
                  << " inner=" << inner_ << "\n";
    }

    ~ElementWrap()
    {
        std::cout << "[wrap dtor] this=" << this
                  << " factory=" << factoryName_ << "\n";
    }

    bool SetProp(const std::string& key, const std::string& val)
    {
        std::cout << "[SetProp ] this=" << this
                  << " 用内部 inner_=" << inner_ << "\n";
        return GobSetProp(inner_, key, val);
    }

public:
    MockGob* inner_;
    std::string factoryName_;
};

这个类是 C++ 对底层 GObject 的包装。它有两个字段:

  • inner_:裸指针,指向真正干活的 MockGob。注意它是裸指针,构造函数里没有调 GobRef(inner_),析构函数里也没有调 GobUnref(inner_)。这就是 bug 的根源:这个类对底层对象没有所有权,只是记了个地址。
  • factoryName_:插件名字字符串,跟着 ElementWrap 一起生死。

构造函数把传进来的 inner 直接塞给 inner_,没有增加引用计数。析构函数只是打印日志,没有释放 inner_。

SetProp 方法内部调 GobSetProp(inner_, ...),用的就是那个裸指针。一旦 inner_ 指向的底层对象已经被释放,这一行就是 UAF。

MockPipeline 类

复制代码
class MockPipeline {
public:
    explicit MockPipeline(std::string name)
        : self_(new MockGob(std::move(name)))
    {
        std::cout << "[pipe new] " << self_->name
                  << " refCount=1(pipeline 自己持有)\n";
    }

    ~MockPipeline() { Destroy(); }

    MockGob* Add(const std::string& childName)
    {
        MockGob* child = new MockGob(childName);
        children_.push_back(child);
        std::cout << "[pipe add] " << child->name
                  << " refCount=1(由 pipeline 持有)\n";
        return child;
    }

    void Destroy()
    {
        if (self_ == nullptr) return;

        std::cout << "[pipe del] 开始释放 pipeline 及子元件\n";
        for (MockGob* c : children_) {
            GobUnref(c);
        }
        children_.clear();

        GobUnref(self_);
        self_ = nullptr;
    }

private:
    MockGob* self_;
    std::vector<MockGob*> children_;
};

这个类模拟 GStreamer 的 pipeline/bin。它自己也是一个 MockGob(self_),还持有一组子元件(children_)。

构造函数 new 一个 MockGob 作为 pipeline 自己,refCount=1。

Add 方法新建一个子元件,放进 children_ 列表,返回指针。新建的子元件 refCount=1,这唯一一份引用由 pipeline 持有。

Destroy 方法做清理:先遍历所有子元件,逐个 GobUnref,让它们的 refCount 从 1 减到 0,对象释放。然后再 GobUnref(self_) 释放 pipeline 自己。

析构函数 ~MockPipeline() 直接调 Destroy(),保证 pipeline 对象离开作用域时一定会清理干净。

输出

bash 复制代码
============================================================
错误版本:shared_ptr 保活了包装壳,但底层 GObject 已被释放
============================================================

--- 步骤 1: 创建 pipeline 并添加子元件 ---
[pipe new] pipeline0 refCount=1(pipeline 自己持有)
[pipe add] channel-selector0 refCount=1(由 pipeline 持有)

--- 步骤 2: 创建 ElementWrap 并放进 elementMap ---
[wrap ctor] this=0000017C3B45A2B0 factory=channel-selector inner=0000017C3B45A630

--- 步骤 3: 用户线程拷出 shared_ptr<ElementWrap> ---
  userElem.use_count() = 2
  此时 GObject refCount = 1(注意:没有因为拷了 shared_ptr 而增加)

--- 步骤 4: 停流线程清空 elementMap 并销毁 pipeline ---
[pipe del] 开始释放 pipeline 及子元件
  [unref ] channel-selector0 refCount=0
  [free  ] channel-selector0 内存已释放(alive=false),此后再用 inner_ 就是 UAF
  [unref ] pipeline0 refCount=0
  [free  ] pipeline0 内存已释放(alive=false),此后再用 inner_ 就是 UAF

--- 步骤 5: 销毁后的状态检查 ---
  userElem.use_count() = 1(包装壳还活着,shared_ptr 保活成功)
  inner->alive = false(底层 GObject 已被释放)
  userElem->inner_ = 0000017C3B45A630(指针值还在,但指向的内存已死)

--- 步骤 6: 用户线程继续调 SetProp,触发 UAF ---
[SetProp ] this=0000017C3B45A2B0 用内部 inner_=0000017C3B45A630
  *** [UAF!] 正在访问已释放的对象 ***
  *** 对象名: channel-selector0
  *** 试图设置: channelIds = 9
  *** 当前状态: alive=false, refCount=0
  *** 后果: 在真实 GStreamer 里这里会段错误 / 堆损坏

============================================================
结论
============================================================
SetProp 返回值 = false
错误根因:
  ElementWrap 构造函数只存裸指针 inner_,没有 GobRef(inner_)。
  所以 shared_ptr<ElementWrap> 只保活了 C++ 包装壳,
  没有保活壳里那个 GObject。
  pipeline 销毁时 GObject refCount 归零被释放,
  用户线程拿着还活着的壳继续调 SetProp,访问已释放内存。
[wrap dtor] this=0000017C3B45A2B0 factory=channel-selector

正确方法

cpp 复制代码
// fixed_demo.cpp
// 修复版本:锁内 GobRef,RAII 自动 GobUnref。
// 与 error_demo.cpp 对比,所有修改点都用 [修改] 注释标出。
//
// 编译:g++ -std=c++14 -Wall fixed_demo.cpp -o fixed_demo
// 运行:./fixed_demo

#include <iostream>
#include <memory>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>

// ============================================================
// 模拟 GObject:与 error_demo 完全相同
// ============================================================

struct MockGob {
    std::string name;
    int refCount;
    bool alive;

    explicit MockGob(std::string n)
        : name(std::move(n)), refCount(1), alive(true)
    {
    }
};

void GobRef(MockGob* o)
{
    if (o == nullptr) return;
    ++o->refCount;
    std::cout << "  [ref   ] " << o->name << " refCount=" << o->refCount << "\n";
}

void GobUnref(MockGob* o)
{
    if (o == nullptr) return;
    --o->refCount;
    std::cout << "  [unref ] " << o->name << " refCount=" << o->refCount << "\n";

    if (o->refCount == 0) {
        o->alive = false;
        std::cout << "  [free  ] " << o->name
                  << " 内存已释放(alive=false)\n";
    }
}

bool GobSetProp(MockGob* o, const std::string& key, const std::string& val)
{
    if (o == nullptr) {
        std::cout << "  [set   ] o == nullptr\n";
        return false;
    }
    if (!o->alive || o->refCount <= 0) {
        std::cout << "  *** [UAF!] 正在访问已释放的对象: " << o->name << "\n";
        return false;
    }
    std::cout << "  [set OK] " << o->name << "." << key << " = " << val << "\n";
    return true;
}

// ============================================================
// C++ 包装类:与 error_demo 基本相同,但多了一个 SetPropOn 方法
// ============================================================

class ElementWrap {
public:
    ElementWrap(MockGob* inner, std::string factoryName)
        : inner_(inner), factoryName_(std::move(factoryName))
    {
        // [修改说明] 这里仍然不 ref。
        // 理由:ElementWrap 的职责是包装,不是持有 GObject 引用。
        // 真正的保活由调用方在锁内通过 GobRef 完成,见 main()。
        std::cout << "[wrap ctor] this=" << this
                  << " factory=" << factoryName_
                  << " inner=" << inner_ << "\n";
    }

    ~ElementWrap()
    {
        std::cout << "[wrap dtor] this=" << this
                  << " factory=" << factoryName_ << "\n";
    }

    bool SetProp(const std::string& key, const std::string& val)
    {
        std::cout << "[SetProp ] this=" << this
                  << " 用内部 inner_=" << inner_ << "\n";
        return GobSetProp(inner_, key, val);
    }

    // [修改] 新增方法:接收外部传入的、已经被 ref 保活的对象。
    // 不再直接用 this->inner_,而是用调用方传进来的 guarded。
    bool SetPropOn(MockGob* guarded,
                   const std::string& key,
                   const std::string& val)
    {
        std::cout << "[SetPropOn] this=" << this
                  << " 用外部 guarded=" << guarded << "\n";
        return GobSetProp(guarded, key, val);
    }

public:
    MockGob* inner_;
    std::string factoryName_;
};

// ============================================================
// 模拟 Pipeline:与 error_demo 完全相同
// ============================================================

class MockPipeline {
public:
    explicit MockPipeline(std::string name)
        : self_(new MockGob(std::move(name)))
    {
        std::cout << "[pipe new] " << self_->name
                  << " refCount=1(pipeline 自己持有)\n";
    }

    ~MockPipeline() { Destroy(); }

    MockGob* Add(const std::string& childName)
    {
        MockGob* child = new MockGob(childName);
        children_.push_back(child);
        std::cout << "[pipe add] " << child->name
                  << " refCount=1(由 pipeline 持有)\n";
        return child;
    }

    void Destroy()
    {
        if (self_ == nullptr) return;

        std::cout << "[pipe del] 开始释放 pipeline 及子元件\n";
        for (MockGob* c : children_) {
            GobUnref(c);
        }
        children_.clear();

        GobUnref(self_);
        self_ = nullptr;
    }

private:
    MockGob* self_;
    std::vector<MockGob*> children_;
};

// ============================================================
// [修改] 新增:RAII 守卫
// 构造时不做事(ref 已在外面做了),析构时自动 GobUnref。
// 作用:保证不管正常返回、提前 break 还是异常,离开作用域一定 unref。
// ============================================================

class GobRefGuard {
public:
    explicit GobRefGuard(MockGob* o) : o_(o) {}
    ~GobRefGuard() { GobUnref(o_); }

    GobRefGuard(const GobRefGuard&) = delete;
    GobRefGuard& operator=(const GobRefGuard&) = delete;

private:
    MockGob* o_;
};

// ============================================================
// 主流程:修复后的正确版本
// ============================================================

int main()
{
    std::cout << "============================================================\n";
    std::cout << "修复版本:锁内 GobRef,RAII 自动 GobUnref\n";
    std::cout << "============================================================\n";

    // 步骤 1:建 pipeline,加子元件(与错误版相同)
    std::cout << "\n--- 步骤 1: 创建 pipeline 并添加子元件 ---\n";
    MockPipeline pipe("pipeline1");
    MockGob* inner = pipe.Add("channel-selector0");

    // 步骤 2:创建 ElementWrap 放进 map(与错误版相同)
    std::cout << "\n--- 步骤 2: 创建 ElementWrap 并放进 elementMap ---\n";
    std::unordered_map<std::string, std::shared_ptr<ElementWrap>> elementMap;
    elementMap["channel-selector0"] =
        std::shared_ptr<ElementWrap>(new ElementWrap(inner, "channel-selector"));

    // 步骤 3:用户线程在锁内查找、拷 shared_ptr、读 inner_、立刻 GobRef
    std::cout << "\n--- 步骤 3: 锁内查找 + GobRef(关键修复点)---\n";
    std::shared_ptr<ElementWrap> userElem;
    MockGob* guarded = nullptr;

    {
        // 模拟持锁:
        //   1. find elementMap
        //   2. 拷出 shared_ptr<ElementWrap>
        //   3. 读出 inner_
        //   4. 立刻 GobRef(guarded)
        // 这整个过程必须持锁,不能中间放锁。
        userElem = elementMap["channel-selector0"];
        guarded = userElem->inner_;
        GobRef(guarded);   // [修改] 关键:让 GObject 引用计数加 1
    }

    // [修改] 立刻建立 RAII 守卫,保证后面一定 unref
    GobRefGuard guard(guarded);

    std::cout << "  userElem.use_count() = " << userElem.use_count() << "\n";
    std::cout << "  GObject refCount = " << guarded->refCount
              << "(pipeline 一份 + guard 一份 = 2)\n";

    // 步骤 4:停流线程清空 map,销毁 pipeline
    std::cout << "\n--- 步骤 4: 停流线程清空 elementMap 并销毁 pipeline ---\n";
    elementMap.clear();
    pipe.Destroy();

    // 步骤 5:检查状态
    std::cout << "\n--- 步骤 5: 销毁后的状态检查 ---\n";
    std::cout << "  guarded->alive = " << std::boolalpha << guarded->alive
              << "(GObject 没被释放,因为 guard 还持有一份引用)\n";
    std::cout << "  guarded->refCount = " << guarded->refCount
              << "(pipeline unref 后从 2 减到 1,没归零)\n";

    // 步骤 6:用户线程用 guarded 调属性设置,安全
    std::cout << "\n--- 步骤 6: 用户线程用 guarded 调 SetPropOn,安全 ---\n";
    // [修改] 不再调 userElem->SetProp(...)(它内部用 inner_,不可信)
    // 而是调 userElem->SetPropOn(guarded, ...)(用自己 ref 过的那份)
    bool ok = userElem->SetPropOn(guarded, "channelIds", "9");

    // 步骤 7:结论
    std::cout << "\n============================================================\n";
    std::cout << "结论\n";
    std::cout << "============================================================\n";
    std::cout << "SetPropOn 返回值 = " << std::boolalpha << ok << "\n";
    std::cout << "与错误版相比,改了三处:\n";
    std::cout << "  1. 锁内拿到 inner_ 后立刻 GobRef(guarded),\n";
    std::cout << "     让 GObject 引用计数加 1,pipeline 销毁时不会归零。\n";
    std::cout << "  2. 用 GobRefGuard RAII 守卫,离开作用域自动 GobUnref,\n";
    std::cout << "     不会泄漏引用计数。\n";
    std::cout << "  3. 调用时用 SetPropOn(guarded, ...) 传入自己 ref 过的对象,\n";
    std::cout << "     不再用 ElementWrap 内部那个裸 inner_。\n";
    std::cout << "\n离开 main,guard 析构自动 GobUnref,\n";
    std::cout << "GObject refCount 从 1 减到 0,真正释放。\n";

    return 0;
}

做了三件事

第一件,在锁内从 map 里找到 ElementWrap、读出 inner_ 这个地址之后,立刻调一次 GobRef。这一下让 MockGob 的引用计数从 1 变成 2。pipeline 手里那份是 1,用户线程手里这份也是 1。这样 pipeline 销毁的时候,它那份 unref 下去,引用计数从 2 变 1,没归零,MockGob 不会被释放。

第二件,加完引用之后,马上建一个 RAII 守卫对象。这个守卫什么都不干,就记着这个 MockGob 的地址,等它自己离开作用域的时候,自动调一次 GobUnref。这样不管后面代码是正常返回、提前 break 还是抛异常,用户线程那份引用一定会被还回去,不会泄漏。

第三件,调属性设置的时候,不再用 ElementWrap 内部那个 inner_,而是把刚才 ref 过的那个指针显式传进去。因为 inner_ 是壳里那个裸指针,语义上不可信,而我自己 ref 过的那份引用才是我能保证活着的对象。

整个修复没有动 ElementWrap 的构造和析构,因为 ElementWrap 的职责就是包装,不应该让它自己去管 MockGob 的引用计数。真正的保活动作放在调用方------在锁内取指针的时候顺手 ref,用完了 RAII 自动 unref。这样两套生命周期各管各的:shared_ptr 管 ElementWrap 这个壳,GobRef/GobUnref 管 MockGob 这个底层对象,两边都保住了,就不会再出现壳活着、人已经走了的情况。

输出

bash 复制代码
============================================================
修复版本:锁内 GobRef,RAII 自动 GobUnref
============================================================

--- 步骤 1: 创建 pipeline 并添加子元件 ---
[pipe new] pipeline1 refCount=1(pipeline 自己持有)
[pipe add] channel-selector0 refCount=1(由 pipeline 持有)

--- 步骤 2: 创建 ElementWrap 并放进 elementMap ---
[wrap ctor] this=000001B4D3003870 factory=channel-selector inner=000001B4D3003640

--- 步骤 3: 锁内查找 + GobRef(关键修复点)---
  [ref   ] channel-selector0 refCount=2
  userElem.use_count() = 2
  GObject refCount = 2(pipeline 一份 + guard 一份 = 2)

--- 步骤 4: 停流线程清空 elementMap 并销毁 pipeline ---
[pipe del] 开始释放 pipeline 及子元件
  [unref ] channel-selector0 refCount=1
  [unref ] pipeline1 refCount=0
  [free  ] pipeline1 内存已释放(alive=false)

--- 步骤 5: 销毁后的状态检查 ---
  guarded->alive = true(GObject 没被释放,因为 guard 还持有一份引用)
  guarded->refCount = 1(pipeline unref 后从 2 减到 1,没归零)

--- 步骤 6: 用户线程用 guarded 调 SetPropOn,安全 ---
[SetPropOn] this=000001B4D3003870 用外部 guarded=000001B4D3003640
  [set OK] channel-selector0.channelIds = 9

============================================================
结论
============================================================
SetPropOn 返回值 = true
与错误版相比,改了三处:
  1. 锁内拿到 inner_ 后立刻 GobRef(guarded),
     让 GObject 引用计数加 1,pipeline 销毁时不会归零。
  2. 用 GobRefGuard RAII 守卫,离开作用域自动 GobUnref,
     不会泄漏引用计数。
  3. 调用时用 SetPropOn(guarded, ...) 传入自己 ref 过的对象,
     不再用 ElementWrap 内部那个裸 inner_。

离开 main,guard 析构自动 GobUnref,
GObject refCount 从 1 减到 0,真正释放。
  [unref ] channel-selector0 refCount=0
  [free  ] channel-selector0 内存已释放(alive=false)
[wrap dtor] this=000001B4D3003870 factory=channel-selector
相关推荐
个 人 练 习 生11 小时前
C++:从零基础到深入了解vector的使用
开发语言·c++·经验分享·学习·程序人生·stl
ShineWinsu11 小时前
对于Qt窗口:QMainWindow、QMenuBar、Qmenu、QAction的解析
c++·qt·菜单·qmainwindow·qaction·qmenu·qmenubar
H.莓飛12 小时前
【C++】【STL】stack_OJ题
服务器·c语言·开发语言·数据结构·c++·算法·visual studio
Rabitebla12 小时前
【Linux操作系统】 文件篇(一):文件描述符与 Linux 文件管理机制
linux·网络·c++·笔记·学习
旖旎夜光15 小时前
【C++ 基础入门】智能指针:RAII、unique_ptr 与 shared_ptr 循环引用
c++·笔记·学习·智能指针
ShineWinsu16 小时前
对于Qt:QSpacerItem常见属性以及方法的解析
开发语言·c++·qt·面试·系统架构·客户端·qspaceritem
ShineWinsu20 小时前
对于Qt:QGripLayout常见属性、方法以及QSizePolicy的解析
开发语言·c++·qt·面试·gui·客户端·网格
艾莉丝努力练剑20 小时前
【AI大模型接入SDK】C++的SessionManager 线程安全
java·开发语言·前端·c++·人工智能·学习·安全
辰小忆20 小时前
11 · RunCurveChart —— 实时运行曲线
c++·ui·duilib