我有一个循环参考。如何在 Objective-C 中创建弱引用？

Question

我正在开发一个 iPhone 应用程序。我有一个Row 类的对象，它需要释放Block 类的许多对象。当前每个Block 都有一个属性，该属性保留Row 类的实例变量。

@interface Block : UIImageView {
  Row *yCoord;
}
@property (nonatomic,retain) Row *yCoord;
@end

每个Row 都包含这些块的NSMutableArray。

@interface Row : NSObject {
    NSMutableArray *blocks;
}
-(void)addBlock:(Block*)aBlock;
@end

@implementation Row
-(void)addBlock:(Block*)aBlock {
    [blocks addObject:aBlock];
    aBlock.yCoord = self;
}
@end

我知道这是一个循环引用。 Apple 的文档指出，为了释放具有循环引用的对象，我需要一个弱引用而不是强引用（保留属性），但它没有贯彻并解释我是如何做到这一点的。我计划同时释放和释放行内的所有块以及行本身。如何在我的每个块中设置对其“父”行的弱引用？

Answer 1

编辑：由于提问者澄清他没有使用垃圾收集（iPhone 目前不支持它），我的建议是通过只保留一个对象来避免循环，就像你会与代表一起做。使用属性时，使用“assign”而不是“retain”来实现这一点。例如：

@property (nonatomic,assign) Row *yCoord;

我的其余答案与 Objective-C 2.0 和 GC 方面的“弱引用”有关。

---

当您使用垃圾回收 (10.5+) 时，通过在变量声明前加上 __weak 来创建弱引用。当您分配给该变量时，GC（如果启用）会跟踪引用，如果对被引用对象的所有强引用都消失了，它将自动为您清零。 （如果未启用 GC，则忽略 __weak 属性。）

因此，您可以安全地修改上述答案以更好地使用垃圾收集（目前在 10.5+，也许有一天会在 iPhone 上）如下：（参见related Apple docs。）

@property (nonatomic,assign) __weak Row *yCoord;

引用Chris Hanson（您可以在其中找到更详细的信息）：

“通过在实例变量声明前加上__weak，您可以告诉垃圾收集器，如果它是对某个对象的唯一引用，则该对象应被视为可收集。”

我会通过说“如果没有对对象的非弱引用”来澄清这一点。一旦最后一个强引用被删除，对象可能会被收集，所有弱引用都会自动归零。

注意：这直接与创建弱引用有关，但也有一个__strong属性，但由于Objective -C 对象变量默认是强引用，它通常仅用于原始 C 指针，指向垃圾收集器不会将其视为根的结构或原语之类的东西，如果你不将它们声明为，它们将从你下面收集强的。 （虽然缺少__weak 可能会导致保留周期和内存泄漏，但缺少__strong 可能会导致内存阻塞以及非确定性发生的非常奇怪和隐蔽的错误，并且很难追踪。）

Answer 2

只需将其更改为分配而不是保留，不再循环引用。

@interface Block : UIImageView {
  Row *yCoord;
}
@property (nonatomic,assign) Row *yCoord;
@end

Answer 3

弱引用只是一个赋值（除非你说的是垃圾收集，它是一个完全独立的蠕虫罐，但不会受到保留周期的影响）。

通常，在 Cocoa 中，Row 会保留 Block 对象（通过将它们包含在 NSMutableArray 中），但 Block 不会保留 Row，每个都将简单地将其存储在 ivar 中（使用 "分配”属性）。

只要Row 在释放每个Block 之前小心地释放它（即，它的dealloc 应该释放NSMutableArray，只要没有其他人有任何指向它们的指针，它就会释放块）然后一切都将酌情释放。

您还可以采取预防措施，在从数组中删除条目之前将块中的行引用归零，例如：

- (void) dealloc {
    for (Block* b in _blocks) {
        b.row = nil;
    }
    [_blocks release];
    [super dealloc];
}

其中 _blocks 是 blocks 属性引用的 ivar。

Answer 4

在多线程系统中使用 assign 创建弱引用可能是不安全的，尤其是当其中一个对象可以被第三个对象保留，然后用于取消引用另一个对象时。

幸运的是，这通常是层次结构的问题，包含弱引用的对象只关心被引用对象的生命周期内它所引用的对象。这是上级下级关系的常见情况。

我认为 OP 评论中的情况与此对应，行 = 上级，块 = 下级。

在这种情况下，我会使用句柄从下级引用上级：

// Superior.h

@class Superior;

@interface SuperiorHandle : NSObject {
    @private
        Superior* superior_;
}

// note the deliberate avoidance of "nonatomic"
@property (readonly) Superior *superior;

@end

@interface Superior : NSObject {
    @private
        SuperiorHandle *handle_;
        // add one or more references to Subordinate instances
}

// note the deliberate avoidance of "nonatomic"
@property (readonly) SuperiorHandle *handle;

@end


// Superior.m

#import "Superior.h"

@implementation SuperiorHandle

@synthesize
    superior = superior_;

- (id)initWithSuperior:(Superior *)superior {
    if ((self = [super init])) {
        superior_ = superior; // weak reference
    }
}

- (void)invalidate {
    @synchronized (self) {
        superior_ = nil;
    }
}

- (Superior *)superior {
    @synchronized (self) {
        // retain and autorelease is required to prevent dealloc before we're ready, thanks to AndroidDev for pointing out this mistake
        return [[superior_ retain] autorelease];
    }
}

@end

@implementation Superior

@synthesize
    handle = handle_;

- (id)init {
    if ((self = [super init])) {
        handle_ = [[SuperiorHandle alloc] initWithSuperior:self];
    }
    return self;
}

- (void)dealloc {
    [handle_ invalidate];
    [handle_ release];

    [super dealloc];
}

@end


// Subordinate.h

@class Superior;
@class SuperiorHandle;

@interface Subordinate : NSObject {
    @private
        SuperiorHandle *superior_handle_;
}

@property (readonly) Superior *superior;

@end


// Subordinate.m

#import "Subordinate.h"

#import "Superior.h"

@implementation Subordinate

// no synthesize this time, superior's implementation is special

- (id)initWithSuperior:(Superior *)superior {
    if ((self = [super init])) {
        superior_handle_ = [superior.handle retain];
    }
    return self;
}

- (void)dealloc {
    [superior_handle_ release];

    [super dealloc];
}

- (Superior *)superior { 
    @synchronized (superior_handle_) {
        return superior_handle_.superior; 
    }
}

@end

一些优点：

1. 它是线程安全的。没有办法让 Subordinate 中包含的弱引用成为无效指针。它可能会变为 nil，但没关系。
2. 只有对象本身需要知道嵌入的弱引用。所有其他对象都可以将下属视为具有对上级的常规引用。