学习block帖子ObjC的Block中使用weakSelf/strongSelf @weakify/@strongify
Objective C 的Block是一个很实用的语法，特别是与GCD结合使用，可以很方便地实现并发、异步任务。但是，如果使用不当，Block 也会引起一些循环引用问题(retain cycle)—— Block 会retain ‘self’，而 ‘self‘又 retain了 Block。因为在 ObjC 中，直接调用一个实例变量，会被编译器处理成‘self->theVar’，’self’ 是一个 strong 类型的变量，引用计数会加 1，于是，self retains queue，queue retains block，block retains self。
解决 retain circle
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 不会被释放。
总结
- 在
Block内如果需要访问self的方法、变量，建议使用weakSelf。 - 如果在
Block内需要多次 访问self，则需要使用strongSelf。
另外
以上内容知道了我们为什么要用weakSelf和strongSelf， 为了简单实用一般会定义成宏weakly和strongly，如下：
方法一： ARC和MRC通用
#ifndef weakify
#if __has_feature(objc_arc)
#define weakify( x ) \
_Pragma("clang diagnostic push") \
_Pragma("clang diagnostic ignored \"-Wshadow\"") \
autoreleasepool{} __weak __typeof__(x) __weak_##x##__ = x; \
_Pragma("clang diagnostic pop")
#else
#define weakify( x ) \
_Pragma("clang diagnostic push") \
_Pragma("clang diagnostic ignored \"-Wshadow\"") \
autoreleasepool{} __block __typeof__(x) __block_##x##__ = x; \
_Pragma("clang diagnostic pop")
#endif
#endif
#ifndef strongify
#if __has_feature(objc_arc)
#define strongify( x ) \
_Pragma("clang diagnostic push") \
_Pragma("clang diagnostic ignored \"-Wshadow\"") \
try{} @finally{} __typeof__(x) x = __weak_##x##__; \
_Pragma("clang diagnostic pop")
#else
#define strongify( x ) \
_Pragma("clang diagnostic push") \
_Pragma("clang diagnostic ignored \"-Wshadow\"") \
try{} @finally{} __typeof__(x) x = __block_##x##__; \
_Pragma("clang diagnostic pop")
#endif
#endif
使用过RAC的同学应该都知道@weakify和@strongify，这两个宏在RAC中是已经定义好的，可以直接用，属于比较牛逼的写法。这两个宏一定成对出现，先@weakify再@strongify.可以很好的管理Block内部对self的引用。可以一步步点开发现其实使用到了C语言中的组合运算符。
@weakify(self);
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
@strongify(self);
[self doSomething];
[self doOtherThing];
});
第二种： 比如RAC
#define weakify(...) \
autoreleasepool {} \
metamacro_foreach_cxt(rac_weakify_,, __weak, __VA_ARGS__)
#define strongify(...) \
try {} @finally {} \
_Pragma("clang diagnostic push") \
_Pragma("clang diagnostic ignored \"-Wshadow\"") \
metamacro_foreach(rac_strongify_,, __VA_ARGS__) \
_Pragma("clang diagnostic pop")
来解释一下RAC怎么实现这种装逼的写法。
他们的作用主要是在block内部管理对self的引用：
@weakify(); 定义了一个__weak的self_weak变量
[RACObserve(, name) subscribeNext:^(NSString *name) {
@strongify(); 局域定义了一个__strong的指针指向self_weak
.outputLabel.text = name;
}];
这个宏为什么这么吊，前面加@，其实就是一个啥都没干的@autoreleasepool {}前面的那个@，为了显眼罢了。 还有metamacro_foreach_cxt, 我们一层一层的往里点
#define metamacro_foreach_cxt(MACRO, SEP, CONTEXT, ...) \
metamacro_concat(metamacro_foreach_cxt, metamacro_argcount(__VA_ARGS__))(MACRO, SEP, CONTEXT, __VA_ARGS__)
继续点下去
#define metamacro_concat(A, B) \
metamacro_concat_(A, B)
#define metamacro_concat_ A ## B
到最后, 才发现, 这不就是个C语言中组合运算符的么, 把2个运算符组合成为1个运算符。 然后回过头看, 他就是吧weak 以及第二步骤中#define rac_weakify_(INDEX, CONTEXT, VAR) \ CONTEXT typeof__(VAR) metamacro_concat(VAR, weak) = (VAR);的typedef拼接进去- -