ObjC的Block中使用weakSelf/strongSelf @weakify/@strongify

学习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拼接进去- -