One problem with using blocks and asynchronous dispatch is that you can get into a retain cycle – the block can retain ‘self’, sometimes in mysterious ways. For instance, if you reference an ivar directly, what appears in the code is ‘theIvar’, the compiler generates ‘self->theIvar’. Thus, ‘self’, as a strong variable, is retained, and the queue retains the block, and the object retains the queue.
Apple recommends first assigning ‘self’ into a weak automatic variable, then referencing that in a block (see 1). Since the block captures the variable along with its decorators (i.e. weak qualifier), there is no strong reference to ‘self’, and the object can get dealloced, and at that moment the weak captured variable turns to nil.
大致意思是：
Block 也会引起一些循环引用问题(retain cycle)—— Block 会 retain ‘self’，而 ‘self‘ 又 retain 了 Block。因为在 ObjC 中，直接调用一个实例变量，会被编译器处理成 ‘self->theVar’，’self’ 是一个 strong 类型的变量，引用计数会加 1，于是，self retains queue， queue retains block，block retains self。
Apple 官方的建议是，传进 Block 之前，把 ‘self’ 转换成 weak automatic 的变量，这样在 Block 中就不会出现对 self 的强引用。如果在 Block 执行完成之前，self 被释放了，weakSelf 也会变为 nil。
示例代码：
__weak __typeof__(self) weakSelf = self; dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
[weakSelf doSomething];
});
clang 的文档表示，在 doSomething 内，weakSelf 不会被释放。但，下面的情况除外：
__weak __typeof__(self) weakSelf = self; dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
[weakSelf doSomething];
[weakSelf doOtherThing];
});
在 doSomething 中，weakSelf 不会变成 nil，不过在 doSomething 执行完成，调用第二个方法 doOtherThing 的时候，weakSelf 有可能被释放，于是，strongSelf 就派上用场了：
__weak __typeof__(self) weakSelf = self;
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
__strong __typeof(self) strongSelf = weakSelf;
[strongSelf doSomething];
[strongSelf doOtherThing];
});
__strong 确保在 Block 内，strongSelf 不会被释放。
总结
1 在 Block 内如果需要访问 self 的方法、变量，建议使用 weakSelf。
2 如果在 Block 内需要多次 访问 self，则需要使用 strongSelf。
参考：
https://dhoerl.wordpress.com/2013/04/23/i-finally-figured-out-weakself-and-strongself/
http://stackoverflow.com/questions/21113963/is-the-weakself-strongself-dance-really-necessary-when-referencing-self-inside-a?rq=1
网友评论
dispatch_async(dispatch_get_global_queue(0, 0), ^{
for (NSInteger i=0; i<10000; i++) {
[weakSelf log:@""];
}
});
多次调用weakSelf 子线程 耗时 仍然走dealloc 什么原因 strongSelf有必要吗 很困惑
另外 我释放block也一样啊 还好封装一些 没必要写weakSelf strongSelf到处写宏
我好奇weakSelf如果在耗时中被释放 再调用log方法应该是会崩溃的 但是并没有出现nil调用log方法导致崩溃的问题
另外这里子线程的block里引用了self 但是self好像并没有引用block啊 这里应该是没有循环引用
这里关键是weakSelf。block在声明时，会将其需要用到的常量copy，object的retainCount+1，也就是保留需要用到的上下文。而weakSelf的作用就是，让block在声明期间不会给self的retainCount+1，而在执行期间才用strongSelf给self的retainCount+1。从而，block在不执行的时候，不会影响self的释放。” 这是@CodeCola 回复Singleton_1990的一个解答，我觉得@CodeCola对这个的理解比我更加的好，所以你可以咨询一下他哦。
楼主，请问这行代码一般都是在哪里使用呢？
- (void)configureBlock {
XYZBlockKeeper * __weak weakSelf = self;
self.block = ^{
[weakSelf doSomething]; // capture the weak reference
// to avoid the reference cycle
}
}
By capturing the weak pointer to self, the block won’t maintain a strong relationship back to the XYZBlockKeeper object. If that object is deallocated before the block is called, the weakSelf pointer will simply be set to nil.
也就是说你在执行doSomething的时候，也有可能被释放。
还有self的释放时机一直有困惑，这次彻底理解了——strongSelf是在block内创建，是个局部变量，block执行完毕，就会release掉。那么同时会减去对self的一次retain计数，不会影响到self的dealloc。
“clang 的文档表示，在 doSomething 内，weakSelf 不会被释放”这一条在您给的链接中看到了，我回头查下clang文档，再次感谢！
楼主，上一条评论有一点瑕疵——“当然不是见到block就要弱引用，您列举的例子确实是不需要的。同样也是可以释放的。” 我给的那个例子是需要weak引用的，不然self持有block，block持有self，互相持有了。
One problem with using blocks and asynchronous dispatch is that you can get into a retain cycle – the block can retain ‘self’, sometimes in mysterious ways. For instance, if you reference an ivar directly, what appears in the code is ‘theIvar’, the compiler generates ‘self->theIvar’. Thus, ‘self’, as a strong variable, is retained, and the queue retains the block, and the object retains the queue.
Apple recommends first assigning ‘self’ into a weak automatic variable, then referencing that in a block (see 1). Since the block captures the variable along with its decorators (i.e. weak qualifier), there is no strong reference to ‘self’, and the object can get dealloced, and at that moment the weak captured variable turns to nil.
导致意思是：
Block 也会引起一些循环引用问题(retain cycle)—— Block 会 retain ‘self’，而 ‘self‘ 又 retain 了 Block。因为在 ObjC 中，直接调用一个实例变量，会被编译器处理成 ‘self->theVar’，’self’ 是一个 strong 类型的变量，引用计数会加 1，于是，self retains queue， queue retains block，block retains self。
也许是习惯，在使用gcd的时候 一般我会直接用宏定义将self弱引用化。当然不是见到block就要弱引用，您列举的例子确实是不需要的。同样也是可以释放的。