我很抱歉，这个问题可能相当基础，但我认为它与很多进入块编程的Objective-C程序员相关。
我听说由于块捕获其中引用的本地变量作为const副本，因此在块内使用self可能会导致循环引用，如果该块被复制。因此，我们应该使用__block来强制块直接处理self，而不是将其复制。
__block typeof(self) bself = self;
[someObject messageWithBlock:^{ [bself doSomething]; }];
不仅仅是
[someObject messageWithBlock:^{ [self doSomething]; }];
我想知道的是：如果这是真的，除了使用GC之外，是否有办法避免这种丑陋的情况？
__block存储类来存储变量。self的值作为参数传递给块。不幸的是，对于大多数API而言，这并没有意义。bself->ivar。__block 不再导致保留循环。如果您正在编译ARC，则需要改用__weak或__unsafe_unretained。__weak也可以。如果您确定在调用块时对象不会超出作用域，则__unsafe_unretained略微更快，但一般情况下这不会有任何区别。如果您使用__weak，请确保将其放入__strong本地变量中，并在执行任何操作之前对其进行非nil测试。 - Lily Ballard__block不保留和释放的副作用纯粹是由于无法正确推理。有了ARC，编译器获得了这种能力，因此__block现在会保留和释放。如果您需要避免这种情况，则需要使用__unsafe_unretained，它指示编译器不对变量中的值执行任何保留或释放操作。 - Lily Ballardself（直接或间接地）保留？我认为只有在块作为strong属性存储在self中时，块才可能被self保留（这似乎不是这种情况）。还有其他任何方式可以使self直接或间接地保留该块吗？ - ken只需使用：
__weak id weakSelf = self;
[someObject someMethodWithBlock:^{
[weakSelf someOtherMethod];
}];
更多信息请参考：WWDC 2011 - 实践中的块和Grand Central Dispatch。
https://developer.apple.com/videos/wwdc/2011/?id=308
注意：如果链接无法打开，您可以尝试
__weak typeof(self)weakSelf = self;
可能显而易见，但只有在知道会出现保留循环时，你才需要使用难看的self别名。如果块只是一次性的事情，那么我认为你可以放心地忽略对self的保留。坏的情况是当你将块用作回调接口时，例如像这样：
typedef void (^BufferCallback)(FullBuffer* buffer);
@interface AudioProcessor : NSObject {…}
@property(copy) BufferCallback bufferHandler;
@end
@implementation AudioProcessor
- (id) init {
…
[self setBufferCallback:^(FullBuffer* buffer) {
[self whatever];
}];
…
}
这里API的意义不是很明显，但在与超类通信时会有意义。我们保留缓冲区处理程序，而缓冲区处理程序则保留我们。与以下代码进行比较：
typedef void (^Callback)(void);
@interface VideoEncoder : NSObject {…}
- (void) encodeVideoAndCall: (Callback) block;
@end
@interface Foo : NSObject {…}
@property(retain) VideoEncoder *encoder;
@end
@implementation Foo
- (void) somewhere {
[encoder encodeVideoAndCall:^{
[self doSomething];
}];
}
在这些情况下，我不会进行自身别名。虽然会出现保留循环，但操作的持续时间很短，而且块最终会从内存中释放，打破循环。但是我的块经验非常小，也许自身别名最终会成为最佳实践。
retain 被完全忽略了（除非它们已经通过 copy 移出了栈）。 - Steven Fisher我发表另一个答案，因为这对我也是个问题。一开始我认为在块内部的任何self引用处都必须使用blockSelf。但事实并非如此，只有当对象本身带有块时才需要使用它。而且，如果在这些情况下使用blockSelf，对象可能会在块返回结果之前被释放，然后在尝试调用时崩溃，所以显然您需要在响应返回之前保留self。
第一种情况演示了循环引用的发生，因为它包含在块中引用的块：
#import <Foundation/Foundation.h>
typedef void (^MyBlock)(void);
@interface ContainsBlock : NSObject
@property (nonatomic, copy) MyBlock block;
- (void)callblock;
@end
@implementation ContainsBlock
@synthesize block = _block;
- (id)init {
if ((self = [super init])) {
//__block ContainsBlock *blockSelf = self; // to fix use this.
self.block = ^{
NSLog(@"object is %@", self); // self retain cycle
};
}
return self;
}
- (void)dealloc {
self.block = nil;
NSLog (@"ContainsBlock"); // never called.
[super dealloc];
}
- (void)callblock {
self.block();
}
@end
int main() {
ContainsBlock *leaks = [[ContainsBlock alloc] init];
[leaks callblock];
[leaks release];
}
在第二种情况下，您不需要使用blockSelf，因为调用对象中没有包含会在引用self时导致保留循环的块：
#import <Foundation/Foundation.h>
typedef void (^MyBlock)(void);
@interface BlockCallingObject : NSObject
@property (copy, nonatomic) MyBlock block;
@end
@implementation BlockCallingObject
@synthesize block = _block;
- (void)dealloc {
self.block = nil;
NSLog(@"BlockCallingObject dealloc");
[super dealloc];
}
- (void)callblock {
self.block();
}
@end
@interface ObjectCallingBlockCallingObject : NSObject
@end
@implementation ObjectCallingBlockCallingObject
- (void)doneblock {
NSLog(@"block call complete");
}
- (void)dealloc {
NSLog(@"ObjectCallingBlockCallingObject dealloc");
[super dealloc];
}
- (id)init {
if ((self = [super init])) {
BlockCallingObject *myobj = [[BlockCallingObject alloc] init];
myobj.block = ^() {
[self doneblock]; // block in different object than this object, no retain cycle
};
[myobj callblock];
[myobj release];
}
return self;
}
@end
int main() {
ObjectCallingBlockCallingObject *myObj = [[ObjectCallingBlockCallingObject alloc] init];
[myObj release];
return 0;
}
self的块可能由于人们过度应用此修复程序而不保留。这是一个很好的避免在非ARC代码中出现保留周期的例子，感谢您的发布。 - Carl Veazeyself，则可能会发生保留循环。self（客户端对象）存在更久，则在释放保留对象本身之前，块中对self的引用不会被视为循环引用。如果服务器对象远远超过其客户端，则可能会导致显著的内存泄漏。doSomethingAndWhenDoneExecuteThisBlock：这样的方法，请使用块，而不是setNotificationHandlerBlock：这样的方法。用于完成的块具有明确的生命周期，并且应在它们被评估后由服务器对象释放。即使出现保留循环，这也可以使保留循环的生命周期不会太长。dealloc而不是release。setEventHandlerBlock：。而是退回到经典的委托模式：创建一个正式协议，并广告setEventDelegate：方法。不要保留委托。如果您甚至不想创建正式协议，请接受作为委托回调的选择器。- (void)dealloc {
[myServerObject releaseCallbackBlocksForObject:self];
...
}
如果您正在尝试从dealloc内部取消连接可能引用self的块，则已经有问题。由于块中的引用引起保留循环，因此可能永远不会调用dealloc，这意味着您的对象将一直泄漏，直到服务器对象被解除分配为止。__weak，GC确实会有所帮助。 - tc.@weakify(self)
[someObject messageWithBlock:^{
@strongify(self)
[self doSomething];
}];
__block __unsafe_unretained 修饰符建议在 Kevin's post 中使用，但在不同线程中执行块时可能会导致访问异常。最好只使用 __block 修饰符来处理临时变量，并在使用后将其设置为 nil。
__block SomeType* this = self;
[someObject messageWithBlock:^{
[this doSomething]; // here would be BAD_ACCESS in case of __unsafe_unretained with
// multithreading and self was already released
this = nil;
}];
这个怎么样？
- (void) foo {
__weak __block me = self;
myBlock = ^ {
[[me someProp] someMessage];
}
...
}
我不再收到编译器警告了。
Block: 包含一个在 block 中被引用的 block，将会导致循环引用； 如果你复制这个 block 并使用成员变量，self 将会被 retain。
self代理称为this，这样可以颠倒一下。在JavaScript中，我把我的this闭包称为self，这样感觉更加平衡。 :) - devios1