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 里把那份引用还回去。
具体场景
- 有一个 C++ 类
ElementWrap,内部包了一个 C 库对象(GObject/GStreamer element),用裸指针inner_存着。 - 这个 C++ 对象放在一个全局 map 里,用
shared_ptr<ElementWrap>管理。 - 线程 A(业务/用户线程) 在锁内从 map 里 find 到这个对象,拷出一份
shared_ptr<ElementWrap>,然后放锁,准备调它的方法设属性。 - 线程 B(停流/清理线程) 同时在做清理:清空 map、销毁底层 pipeline。pipeline 一销毁,它持有的那些 GObject 引用计数归零,内存被真正 free 掉。
- 线程 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 已经销毁了。
凡是满足下面三个条件,基本就会复现:
- C++ 对象内部持有一个 C 库的裸指针(GObject、GStreamer、libav、sqlite 句柄、文件句柄都算)。
- 这个 C++ 对象被多线程访问,一个线程在用,另一个线程在销毁底层资源。
- 用
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 对象在它的整个生命周期里,这三个字段是这样变化的:
new的时候:name="channel-selector0",refCount=1,alive=true。- 别人
GobRef:refCount加 1,name和alive不变。 - 别人
GobUnref:refCount减 1。如果减到 0,alive变成 false。 - 在
alive=true期间访问它,正常工作。 - 在
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