【问题标题】:What is the cyclic dependency issue with shared_ptr?shared_ptr 的循环依赖问题是什么?
【发布时间】:2020-12-04 08:48:53
【问题描述】:

我阅读了共享指针并了解了如何使用。但我从来不理解共享指针的循环依赖问题以及弱指针如何解决这些问题。谁能把这个问题解释清楚吗?

【问题讨论】:

  • 如果您需要另一个关键字进行谷歌搜索,它也称为retain cycle

标签: c++ shared-ptr weak-ptr


【解决方案1】:

问题并不复杂。让-->代表一个共享指针:

The rest of the program  --> object A --> object B
                                    ^     |
                                     \    |
                                      \   v
                                        object C

所以我们得到了一个带有共享指针的循环依赖。每个对象的引用计数是多少?

A:  2
B:  1
C:  1

现在假设程序的其余部分(或至少包含指向 A 的共享指针的部分)被销毁。那么 A 的 refcount 减 1,所以循环中每个对象的引用计数都是 1。那么删除了什么?没有。但是我们要删除什么?一切,因为我们的任何对象都无法从程序的其余部分访问。

因此,在这种情况下,解决方法是将链接从 C 更改为 A 为弱指针。弱指针不影响其目标的引用计数,这意味着当程序的其余部分释放 A 时,它的引用计数为 0。所以它被删除,因此 B 也如此,C 也如此。

不过,在程序的其余部分释放 A 之前,C 可以通过锁定弱指针随时访问 A。只要 C 主动与 A 做事情,这就会将其提升为共享指针(并将 A 的引用计数增加到 2)。这意味着如果在此过程中以其他方式释放 A,那么它的引用计数只会下降到 1。 C 中使用 A 的代码不会崩溃,并且只要该短期共享指针被破坏,A 就会被删除。这是锁定弱指针的代码块的末尾。

一般来说,决定将弱指针放在哪里可能很复杂。您需要在循环中的对象之间存在某种不对称性,以便选择打破它的位置。在这种情况下,我们知道 A 是程序其余部分引用的对象,因此我们知道打破循环的地方就是指向 A 的任何地方。

【讨论】:

  • 谢谢史蒂夫。我现在明白了。感谢您的明确解释。
  • 不确定这是否是解释循环依赖的正确示例。引用计数在控制块中维护,所有共享的指针 A、B、C 将指向同一个控制块,计数 = 3。
【解决方案2】:
shard_ptr<A> <----| shared_ptr<B> <------
    ^             |          ^          |
    |             |          |          |
    |             |          |          |
    |             |          |          |
    |             |          |          |
class A           |     class B         |
    |             |          |          |
    |             ------------          |
    |                                   |
    -------------------------------------

现在如果我们将B类和A类的shared_ptr设为两个指针的use_count是2。

当 shared_ptr 超出 od 范围时,计数仍保持为 1,因此 A 和 B 对象不会被删除。

class B;

class A
{
    shared_ptr<B> sP1; // use weak_ptr instead to avoid CD

public:
    A() {  cout << "A()" << endl; }
    ~A() { cout << "~A()" << endl; }

    void setShared(shared_ptr<B>& p)
    {
        sP1 = p;
    }
};

class B
{
    shared_ptr<A> sP1;

public:
    B() {  cout << "B()" << endl; }
    ~B() { cout << "~B()" << endl; }

    void setShared(shared_ptr<A>& p)
    {
        sP1 = p;
    }
};

int main()
{
    shared_ptr<A> aPtr(new A);
    shared_ptr<B> bPtr(new B);

    aPtr->setShared(bPtr);
    bPtr->setShared(aPtr);

    return 0;  
}

输出:

A()
B()

从输出中我们可以看到,A 和 B 指针永远不会被删除,因此内存泄漏。

为避免此类问题,只需在 A 类中使用 weak_ptr 而不是 shared_ptr,这样更有意义。

【讨论】:

  • 我觉得解释不够。如果 B 类的对象被破坏会发生什么?在“for dummy”解释中,它破坏了自身内部的对象。因此它调用了shared_ptr 对象的销毁,从而导致A 类的对象的销毁。好的,A 破坏了指向B's 对象的shared_ptr。 B 的哪个状态会看到 A:被摧毁/半毁坏/仍然存在?然后呢?为什么在运行时会忽略此行为?为什么不抛出异常?
猜你喜欢
  • 2020-02-28
  • 1970-01-01
  • 2022-01-23
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
相关资源
最近更新 更多