标签: reference-counting

在我的代码中,我使用了一个小型数据存储类,它在不同的地方创建.为了避免内存泄漏并简化操作,我想使用引用计数,所以我做到了

type TFileInfo = class (TInterfacedObject, IInterface)

并删除了我对TFileInfo.Free的所有手动调用.不幸的是Delphi报告了很多内存泄漏.搜索SO我发现以下问题解释了为什么这不起作用:

为什么不收集TInterfacedObject垃圾的后代？

这里有一个解决方法,但它需要我(至少如果我做对了)编写一个自定义接口IFileInfo并为它提供了许多getter和setter,我想避免它.

编辑我应该补充一点,我将创建的FileInfo对象插入到两种不同类型的哈希表中:一个来自TBucketList,另一个是来自Codegear论坛的哈希映射实现.在内部它们都是用户指针,因此情况就像在另一个问题中一样.

还有其他可能使Delphi中的对象使用引用计数吗？

以下行实际上做了什么？

string = @"Some text";

假设在字段中声明了"string":

NSString *string;

"="实际上在这里做了什么？它对"字符串"的引用计数有什么作用？特别是,假设由于某种原因"字符串"没有另外分配,是否需要释放？

谢谢!

你如何使用std.typecons.RefCounted!(T)D中的引用计数对象？

我试图std.array.Array通过查看源代码来弄清楚内部是什么,但是虽然我可以阅读源代码,但我无法确定什么是"有效负载"或者当有涉及按位结构复制的事情时它是如何工作的,以及为什么有些东西在内部和外部结构中重复.

任何人都可以提供一个示例或链接,如何使用它,比如,包装一个简单的Win32 HANDLE？

谢谢!

我一直想知道为什么Java中的垃圾收集器会在它感觉到而不是执行时激活:

if(obj.refCount == 0)
{
   delete  obj;
}

我忽略了Java如何做到这一点有什么大的优势吗？

谢谢

我正在阅读这篇关于PHP变量引用的文章:http://derickrethans.nl/talks/phparch-php-variables-article.pdf 并且想要检查我的理解是否正确,关于何时创建新的变量容器.

对于非数组,只要您指定一个未指向设置了is_ref的容器的变量,就会创建变量容器.

Ex 1 (let {..} be a container):
$a = 1;     // "a" => {integer, 1, is_ref = 0, ref_count = 1}

$b = $a;    // "a", "b" => {integer, 1, is_ref = 0, ref_count = 2}

$b = 2;     // "a" => {integer, 1, is_ref = 0, ref_count = 1}
            // "b" => {integer, 2, is_ref = 0, ref_count = 1}

Ex 2:
$a = 1;     // "a" => {integer, 1, is_ref = 0, …

当我对这个对象进行保留计数时,它是2.这是为什么？当然它应该是一个,因为我刚刚初始化它并没有分配它或任何东西......

let testC: TestClass = TestClass()
print(CFGetRetainCount(testC))

这是在一个空的单视图xcode项目中完成的... TestClass是一个空类,viewcontroller实例化它一次,保留计数为2:

引自C++ Primer $ 12.1.6:

A weak_ptr(表12.5)是一个智能指针,它不控制它指向的对象的生命周期.相反,weak_ptr指向由a管理的对象shared_ptr.将weak_ptr绑定到shared_ptr 不会更改其引用计数shared_ptr.一旦shared_ptr指向对象的最后一个消失,对象本身将被删除.即使有weak_ptrs指向它的名称weak_ptr,该对象也将被删除 -因为该名称捕获了一个weak_ptr"虚弱地"共享其对象的想法.

但是,我读过一篇文章说:

使用make_shared更有效率.shared_ptr实现必须将管理信息保存在由引用给定对象的所有shared_ptrs和weak_ptrs共享的控制块中.特别是,该管家信息不仅包括一个而且包括两个参考计数:

1. "强引用"计数用于跟踪当前使对象保持活动状态的shared_ptrs的数量.当最后一个强引用消失时,共享对象被销毁(并可能被解除分配).

2. "弱引用"计数用于跟踪当前正在观察对象的weak_ptrs的数量.当最后一个弱引用消失时,共享内务控制块被销毁并解除分配(如果共享对象尚未释放,则将其解除分配).

据我所知,shared_ptr创建的make_shared是与那些引用计数在同一个控制块中weak_ptr.所以在最后一个到期之前对象不会被释放.

题:

1. Primer错了吗？因为weak_ptr实际上会影响该对象的生命周期.
2. 为什么shared_ptr需要跟踪它的弱引用？weak_ptr可以通过检查控制块中的强引用来判断对象是否存在,所以我认为控制块不需要跟踪弱引用.

3. 只是出于好奇,控件块的shared_ptr外观是什么样的？它是这样的:

   template<typename T>
   class control_block
   {
      T object;
      size_t strong_refs;
      size_t weak_refs;
      void incre();
      void decre();
      //other member functions...
   };
   //And in shared_ptr:
   template<typename T>
   class …

   Run Code Online (Sandbox Code Playgroud)

我试图了解以下之间的优缺点：

• 使用 Arc 并克隆 Arc（我在不同的地方/线程中使用 Something）

与

• 使用 Something.clone() （我的 Something 结构只有 1 个已可克隆的字段）

除了测量和比较性能结果（我认为两者中的任何一个在性能方面都不会差很多）之外，我还试图了解在锈类动物的头脑中什么被认为是“通常更好”或“更惯用”。

如果我理解正确的话：

• Arc 和克隆：我在堆上有 1 个东西（与堆栈相比昂贵）+我正在克隆 Arc（与 Rc.clone 相比昂贵，但如果我需要跨线程使用则需要），所以我根据方式创建/删除 N 个 Arc很多次我克隆/删除

与

• Something.clone：我在堆栈上创建/删除 N 个 Something 实例，具体取决于我克隆/删除的次数

在这种情况下（“某些东西”的创建成本很低），与仅克隆它相比，将其包装在 Arc 中是否有任何好处？这两个选项中哪一个更可取？

我有一个非常复杂的课程:

class C:
    pass

我有这个测试代码:

for j in range(10):
    c = C()
    print c

这使 :

<__main__.C instance at 0x7f7336a6cb00>
<__main__.C instance at 0x7f7336a6cab8>
<__main__.C instance at 0x7f7336a6cb00>
<__main__.C instance at 0x7f7336a6cab8>
<__main__.C instance at 0x7f7336a6cb00>
<__main__.C instance at 0x7f7336a6cab8>
<__main__.C instance at 0x7f7336a6cb00>
<__main__.C instance at 0x7f7336a6cab8>
<__main__.C instance at 0x7f7336a6cb00>
<__main__.C instance at 0x7f7336a6cab8>

人们可以很容易地看到Python切换到两个不同的值.在某些情况下,这可能是灾难性的(例如,如果我们将对象存储在其他复杂对象中).

现在,如果我将对象存储在List中:

lst = []
for j in range(10):
    c = C()
    lst.append(c)
    print c

我明白了:

<__main__.C instance at 0x7fd8f8f7eb00>
<__main__.C instance at 0x7fd8f8f7eab8> …

考虑以下向量：

std::vector<std::shared_ptr<X>> myVector;

以及以下两个将给定元素添加到向量的函数：

void foo1(std::shared_ptr<X> x)
{
    myVector.push_back(x);
}

void foo2(const std::shared_ptr<X>& x)
{
    myVector.push_back(x);
}

我的理解是，这两个函数都将 a 推shared_ptr入X向量中，从而增加 的引用计数X。第一个函数导致引用计数的额外递增和递减，但这是不必要的。

我的理解正确吗？那么第二种选择是否更可取呢？