标签: reference-counting

我试图理解 LFRC 算法，但我不断寻找一些我认为它们有效的例子，但我不明白为什么。我专注于复制和删除。特别是三个都遵循相同的一般模式（伪代码）：

Copy {
  shared = source->shared;
  if (shared != null) {
     Atomically_Increment_Counter(shared);
  }
}

Delete {
  if (shared != null) {
     oldcounter = Atomically_Decrement_Counter(shared);
     if (oldcounter == value signifying all references released) {
        Deallocate(shared);
     }
  }
}

首先来自David L. Detlefs 于2004 年发表的论文《无锁引用计数》，图 2，第 8 页（已编辑格式）：

void LFRCCopy(SNode **v, SNode *w) {
   Snode *oldv = *v;
   if (w != null) 
      add_to_rc(w,1);
   *v = w;
   LFRCDestroy(oldv);
}

void LFRCDestroy(SNode *v) {
   if (v != null …

我想创建一些对strwith Rc， without cloning 的引用str：

fn main() {
    let s = Rc::<str>::from("foo");
    let t = Rc::clone(&s); // Creating a new pointer to the same address is easy
    let u = Rc::clone(&s[1..2]); // But how can I create a new pointer to a part of `s`?

    let w = Rc::<str>::from(&s[0..2]); // This seems to clone str
    assert_ne!(&w as *const _, &s as *const _);
}

操场

我怎样才能做到这一点？

人们通常如何管理复制大型物体列表？

这是我的情况:

目前我有这个:

typedef std::vector<float> Image;  

我把它存放在一个

std::list<Image> lst;

Image.size()非常大(每个大约3-5 MB).

我正在传递(复制)列表.

我是否正确理解std :: vector将按值复制每个元素？如果是这样,由于过度复制,性能可能有点糟糕？

我该怎么做才能减少复制？我应该存储

std::list<ImageRef> lst;

哪里

typedef boost::shared_ptr<Image>   ImageRef;

？

处理这类问题的优雅方式是什么？

我有一个实现引用计数机制的对象.如果对它的引用数变为零,则删除该对象.

我发现我的对象永远不会删除,即使我完成了它.这导致内存过度使用.我所拥有的只是对象的引用数量,我想知道引用它的位置,以便我可以编写适当的清理代码.

有没有办法完成这个而不必在源文件中grep？(那会非常麻烦.)

基本上我需要对某些资源(如整数索引)进行引用计数,这些资源并不等同于指针/地址语义; 基本上我需要传递资源,并在计数达到零时调用某些自定义函数.读取/写入资源的方式也不是简单的指针引用操作,而是更复杂的操作.我不认为boost :: shared_ptr会适合这里的账单,但也许我错过了一些我可能会使用的其他提升等价类？

我需要做的例子:

struct NonPointerResource
{
   NonPointerResource(int a) : rec(a) {} 

   int rec;
}

int createResource ()
{
   data BasicResource("get/resource");
   boost::shared_resource< MonPointerResource > r( BasicResource.getId() , 
    boost::function< BasicResource::RemoveId >() );
   TypicalUsage( r );
}  
//when r goes out of scope, it will call BasicResource::RemoveId( NonPointerResource& ) or something similar


int TypicalUsage( boost::shared_resource< NonPointerResource > r )
{
   data* d = access_object( r );
   // do something with d
}

我是Objective-C的新手,我觉得C++很有用.

我的问题是: 为什么obj-c的语言设计者适当使用retain/release而不是仅使用new/delete(= alloc/dealloc)？

也许我的大脑适合新的/删除只有内存管理,我无法理解为什么我应该管理引用计数,我想我知道什么时候对象必须与我的C++经历alloc/dealloc.

(是的,我花了4个小时来调试引用计数问题,它由1行"释放"解决)

任何人都可以解释一下,当我们使用参考计数器时哪些更好 (在编程语言方面)我认为我可以通过new/delete来管理对象的生命周期,但是我不能用引用计数.

我需要一篇长篇文章来解释为什么参考计数器很有用,如果你有链接的话.

PS:我在WWDC 2011上听说过编译时自动引用计数,它真的很棒,例如,它可能是使用参考计数器的原因.

我开始使用Objective-C开发并尝试理解弱和强引用.我想我明白了,但我不确定...

让我们考虑一下代码:

@interface SomeClass {} 
@property (nonatomic, weak) NSString* propertyName;
@end

现在,如果我在代码中的某个地方调用这样的东西:

NSString* s = someClassInstance.propertyName;

参考计数器不会递增.我的理解是否正确？

• 疑问1:什么是参考计数器值propertyName？

• 怀疑2:那么......你能举例说明我什么时候可以获得对这个属性的强烈引用？我希望你知道我的意思或我不明白的东西......

我会得到弱参考.

我试图理解引用计数是如何工作的,所以我禁用了ARC并编写了一个简单的类:( Foo.h未粘贴,因为它未被修改)

Foo.m

@implementation Foo

- (instancetype)init
{
    NSLog(@"Init object");
    return [super init];
}

- (void)dealloc
{
    NSLog(@"Dealloc object");
    [super dealloc];
}

@end

的main.m

#import <Foundation/Foundation.h>
#import "Foo.h"

int main(int argc, const char * argv[]) {

    Foo *obj = [[Foo alloc] init];

    obj = nil;
    return 0;
}

现在我希望看到dealloc object日志,因为Foo对象的唯一引用已经消失,但我得到的唯一消息是init object.

我为什么不看？分配时是否释放了对象obj = nil？

我可以在Scheme中创建一个循环数据结构,如下所示:

(define my-pair (cons 1 1))
(set-car! my-pair my-pair)

是否可以在Scheme中创建循环数据结构而不使用变异？(我正准备关于引用计数限制的讲座.)

我当前的代码如下所示:

program Project1;

{$APPTYPE CONSOLE}
{$R *.res}

uses
  Winapi.Windows,
  System.Generics.Collections,
  System.SysUtils;

type
  TForm1 = class
  public
    Events: TList<TProc>;
    constructor Create;
    destructor Destroy; override;
  end;

  TTracingInterfacedObject = class(TInterfacedObject)
  public
    function _AddRef: Integer; stdcall;
    function _Release: Integer; stdcall;
  end;

  ISharedPtr<T> = interface
    ['{CC9EE6C5-F07B-40E5-B05D-2DFDBD3404A1}']
    function Get: T;
    function GetRefCount: Integer;
  end;

  ICatalog = interface
    ['{F421BBA8-8DA3-47EE-ADB9-DED26747472E}']
    function GetView: ISharedPtr<TForm1>;
    property View: ISharedPtr<TForm1> read GetView;
  end;

  ITree = interface
    ['{A1E2F71B-124B-48DB-B038-5F90AC5BE94B}']
    function GetId: TGUID;
    property Id: TGUID read GetId;
  end;

  TSharedPtr<T: class> = class(TTracingInterfacedObject, ISharedPtr<T>)
  private …