简述@weakify、@strongify

最新推荐文章于 2022-03-20 16:03:00 发布

马拉萨的春天

最新推荐文章于 2022-03-20 16:03:00 发布

阅读量1.4k

点赞数

分类专栏：一天一读基础知识点文章标签：循环引用 ios

原文链接：https://www.jianshu.com/p/9e2c36482cc2

版权

一天一读同时被 2 个专栏收录

473 篇文章 11 订阅

订阅专栏

基础知识点

293 篇文章 4 订阅

订阅专栏

前言

在开发中，经常在控制器中用到block语句，在block语句中如果需引用self，而self（控制器）对象中又持有block对象，就会造成循环引用循环引用，导致内存泄露，比如以下代码：

self.block = ^{
        [self test];
    };

一般我们是用一个__weal修饰的weakSelf变量指向self对象，在block中使用weakSelf:

__weak typeof(self) weakSelf = self;
    self.block = ^{
        [weakSelf test];
    };

但是这样子写有可能出问题，因为weakSelf是弱引用，而self一旦释放了，weakSelf可能为nil，还是举个例子吧:

1.先定义一个Persion对象，他的属性有一个block对象:

@interface Persion : NSObject
@property (nonatomic, copy)void(^block)();
@end

@implementation Persion
- (void)dealloc {
    NSLog(@"%s",__func__);}

- (instancetype)init {
    self = [super init];
    if (self) {
        __weak typeof(self) weakSelf = self;
        self.block = ^{
            dispatch_async(dispatch_get_global_queue(0, 0), ^{
                [NSThread sleepForTimeInterval:1];
                NSLog(@"%@",weakSelf);
            });
        };
    }
    return self;
}

@end

2.在其他类的方法中调用的时候：

-(void)test{
Persion *obj = [Persion new];
 obj.block();
}

结果是打印的是(null)，因为block里打印的方法是异步执行的，在 NSLog(@"%@",weakSelf);这句代码执行之前test函数就结束，所以obj对象已经被release了。

怎么解决呢？所以再对weakSelf做一次 __strong就可以了:

__weak typeof(self) weakSelf = self;
        self.block = ^{
            __strong typeof(weakSelf) strongSelf = weakSelf;
            dispatch_async(dispatch_get_global_queue(0, 0), ^{
                [NSThread sleepForTimeInterval:1];
                NSLog(@"%@",strongSelf);
            });
        };}

使用了__strong在strongSelf变量作用域结束之前，对weakSelf有一个引用，防止对象(self)提前被释放。而作用域一过，strongSelf不存在了，对象(self)也会被释放。

1.问题

前面的写法虽然解决了问题了，但是作为喜欢偷懒的程序猿，会不会觉得很啰嗦？每次都要写那两条长长的__weak和__strong，而且在block里用到的self的全部要改成strongSelf，假设把一段很多self的代码拷贝到block里，一个个改成strongSelf是不是很蛋疼？

2.RAC是怎么解决的

@weakify(self);
[[button rac_signalForControlEvents:UIControlEventTouchUpInside] subscribeNext:^(id x) {
    @strongify(self);
    [self popViewControllerAnimated:YES];
}];

只要在block外用了@weakify(self);然后再block里写@strongify(self);就可以了，@strongify(self);语句后的的self可以原封不动，好像很神奇，下面一起看看@weakify、@strongify 这两个神奇的宏最终替换了什么东西。
导入RAC的头文件，把上面的测试代码替换成RAC中用的@weakify(self)和@strongify(self), 分屏显示Xcode，让右侧的显示内容改为 preprocess“,就可以看到宏最终替换的结果。

实际上从Xcode 4开始就有预处理和汇编的功能，能够非常方便的查看一个源文件的预处理结果或者汇编代码

两种方式查看处理结果

1.使用菜单 Product > Perform Action > Preprocess "xxx"(要看看的类文件名)
2.使用辅助编辑器打开辅助编辑器后，编辑编辑器上面选择文件的地方，从弹出菜单中执行Preprocess或Assembly功能。

1477449971163028.jpg

@autoreleasepool {} 是什么鬼？
注意到@weakify(self)前面的@颜色并不是橙色没有？@并不属于宏的一部分，当然你不能平白无故写个@对吧，所以RAC的weakify宏定义机智地给你补了一句autoreleasepool {} 这样一前一后就变成了啥事都没干的@autoreleasepool {}
__attribute__((objc_ownership(weak)))是什么鬼？
这个就是__weak在编译前被编译器替换的结果，weakify这个宏后面最终替换成__weak（后面说到），所以编译器再替换就成了__attribute__((objc_ownership(weak)))

2.weakify、strongify的定义

预备知识

...和 __VA_ARGS__ 看下NSLog和printf，他们的传入参数有多个，用...表示不确定参数个数，看看NSLog的定义： NSLog(NSString *format, ...)
在宏里也可以用...来表示多个参数，而__VA_ARGS__就对应多个参数的部分。举个例子，你觉得NSLog太难看，想造一个自己的log打印函数，比如Zlog你就可以这么写：
#define Zlog(...) NSLog(__VA_ARGS__)

2.##是宏连接符，会将 ##左右两边连接起来，
举个例子：宏定义为#define XLink(n) x##n，这宏的意思是把x和传入的n连接起来书写:


int x1 = 1;int x2 = 2;int x3 = 3;//打印x1 x2 x3NSlog(@"%zd",XLink(1)); //NSlog(@"%zd",x1);NSlog(@"%zd",XLink(2)); //NSlog(@"%zd",x2);NSlog(@"%zd",XLink(3)); //NSlog(@"%zd",x3);

一层层展开weakify

假设我们写了@weakify(self) 发生了什么
第一层：


#define weakify(...)     rac_keywordify   metamacro_foreach_cxt(rac_weakify_,, __weak, __VA_ARGS__)

rac_keywordify实际上就是autoreleasepool {}的宏替换

而VA_ARGS就是对应我们传入的参数
这里我们就可以变成这样：

 autoreleasepool {} 
    metamacro_foreach_cxt(rac_weakify_,, __weak, self)

第二层：


#define metamacro_foreach_cxt(MACRO, SEP, CONTEXT, ...)         metamacro_concat(metamacro_foreach_cxt, metamacro_argcount(__VA_ARGS__))(MACRO, SEP, CONTEXT, __VA_ARGS__)

这一层开始就比较神奇了，
替换第一层的结果就变成这样：

    autoreleasepool {}
    metamacro_concat(metamacro_foreach_cxt, metamacro_argcount(self))(rac_weakify_,  , __weak, self)

我们先看metamacro_argcount(self)这部分，metamacro_argcount(...)这个宏很强大，可以替换可变参数(...)的个数：
举个例子
metamacro_argcount(@"obj") > 会被替换成1
metamacro_argcount(@"obj"，@“obj”) > 会被替换成2
所以metamacro_argcount(self) > 会被替换成1(只有一个参数)
再看看metamacro_concat的定义：

#define metamacro_concat(A, B)         metamacro_concat_(A, B)

居然还包了一次，那好，再点进去看看metamacro_concat_的定义

#define metamacro_concat_(A, B) A ## B

嗯，搞了半天就是之前说到的宏连接符 ##
所以metamacro_concat(A, B) 就是把A、B连接起来变成AB
根据上面分析的metamacro_argcount(self) > 1 ，再用metamacro_concat连接：

 autoreleasepool {}
    metamacro_foreach_cxt ## 1 (rac_weakify_,  , __weak, self)

也就是：

 autoreleasepool {}
    metamacro_foreach_cxt1(rac_weakify_,  , __weak, self)

第三层：
metamacro_foreach_cxt1 没错,不要怀疑，他还定义了metamacro_foreach_cxt1这个后面数组为1的宏，搜索一下：

1477449950329533.jpg

嗯，你没猜错，有metamacro_foreach_cxt1就有metamacro_foreach_cxt2、3、4、5、6、7、8...，
这些是什么鬼，我们先不管，先看我们的metamacro_foreach_cxt1

#define metamacro_foreach_cxt1(MACRO, SEP, CONTEXT, _0) MACRO(0, CONTEXT, _0)

替换第二层分析的结果：

autoreleasepool {}rac_weakify_（0,__weak,self）

额，好像明朗起来了，毫不犹豫看看rac_weakify这个宏是怎么定义的：


#define rac_weakify_(INDEX, CONTEXT, VAR)     CONTEXT __typeof__(VAR) metamacro_concat(VAR, _weak_) = (VAR);

再替换一次：
__weak __typeof__(self) self ## _weak_ = self
最终真相大白变成：

autoreleasepool {}__weak __typeof__(self) self_weak_ = self

同理strongify(self) 这个宏最终展开是这样的，注意这里他重新定义了self，在block语句块里面是允许这么干的，之后用self就是文章一开头的使用strongSelf一样。

autoreleasepool {}__typeof__(self) self = self_weak_;

裤子都脱了你就给我看这个?有人要问了为什么不直接用
rac_weakify_就好，搞那么复杂饶了一大圈，这不是装逼么 - -
其实饶了一大圈的函数就是 @weakify(...);可以支持最多20个参数
比如： @weakify(ob1,obj2...,obj20);
最终会替换成：


@autoreleasepool {}__weak type(obj1) obj1_weak_ = obj1;__weak type(obj2) obj2_weak_ = obj2;...__weak type(obj20) obj20_weak_ = obj20;

下面，我们来讲一讲RAC是怎么装逼的。

3.RAC装逼宏

metamacro_argcount 的定义

前面说过metamacro_argcount这个宏可以把可变参数...替换成参数的个数，看看他的定义:


#define metamacro_argcount(...)         metamacro_at(20, __VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)

一脸懵逼？没关系，我们一层层来看：
假设：metamacro_at(self)
就变成：
metamacro_at(20, self, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)

看看metamacro_at的定义


#define metamacro_at(N, ...)         metamacro_concat(metamacro_at, N)(__VA_ARGS__)

替换进去就是

metamacro_concat(metamacro_at, 20)(self, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)

之前已经知道metamacro_concat是连接宏，所以变成


metamacro_at20(self, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)

搜索metamacro_at20

1477449910278613.jpg

呵呵又是一堆乱七八糟的，没事看懂一个就全懂了。


#define metamacro_at20(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, ...) metamacro_head(__VA_ARGS__)

嗯，这个宏的意思就是去掉传入参数中前20个参数，把剩下的参数传入metamacro_head宏，上面的metamacro_at20 前20个参数就是:
self, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2
所以剩下的参数是 1
假设一开始不是 metamacro_at(self)而是两个或多个参数会发生什么？
比如 metamacro_at(self,self)？
根据上面的规则替换，就会变成

metamacro_at20(self,self, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)

除去前面20个参数，剩下只有 2，1 所以把 2,1 这两个参数传入metamacro_head（2,1）
看看的metamacro_head的定义

#define metamacro_head(...)         metamacro_head_(__VA_ARGS__, 0)

又是一层，继续点进去metamacro_head_

#define metamacro_head_(FIRST, ...) FIRST

其实就是截取第一个参数，所以
metamacro_head（2,1）就是 2。
而前面的metamacro_head（1）就是 1。
到这里相信你已经弄清楚 metamacro_at 是怎么替换成参数个数的了

其他metamacro_at 也是一个道理

metamacro_foreach_cxt 的定义

回过头看metamacro_foreach_cxt

#define metamacro_foreach_cxt1(MACRO, SEP, CONTEXT, _0) MACRO(0, CONTEXT, _0)
#define metamacro_foreach_cxt2(MACRO, SEP, CONTEXT, _0, _1)     metamacro_foreach_cxt1(MACRO, SEP, CONTEXT, _0)     SEP     MACRO(1, CONTEXT, _1)
#define metamacro_foreach_cxt3(MACRO, SEP, CONTEXT, _0, _1, _2)     metamacro_foreach_cxt2(MACRO, SEP, CONTEXT, _0, _1)     SEP     MACRO(2, CONTEXT, _2)
省略N多行

回到最开始，举个例子
metamacro_argcount(obj1,obj2,obj3)
通过上面metamacro_argcount宏，确定出参数为3后，对号入座传入
metamacro_foreach_cxt3

#define metamacro_foreach_cxt3(MACRO, SEP, CONTEXT, _0, _1, _2)     metamacro_foreach_cxt2(MACRO, SEP, CONTEXT, _0, _1)     SEP     MACRO(2, CONTEXT, _2)

所以也就变成了

metamacro_foreach_cxt3(rac_weakify_, , __weak , obj1 ,obj2 ,obj3)

发现是个递归，也就是

metamacro_foreach_cxt2(rac_weakify_, , CONTEXT, obj1, obj2) rac_weakify_(2, __weak, obj3)

而metamacro_foreach_cxt2 又是一层递归，最后
obj1、obj2、obj3都被替换成了:

__weak type(obj1) obj1_weak_ = obj1;__weak type(obj2) obj2_weak_ = obj2;__weak type(obj3) obj3_weak_ = obj3;

RAC的宏装逼过程总结

其实总结起来很简单，就2点：

通过metamacro_argcount确定可变参数个数x
根据1得到的x调用metamacro_foreach_cxtx,层层递归，对每个参数进行宏替换

用法

传统写法在项目中一般可以声明宏：

#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

#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")

主要参考自文章

马拉萨的春天

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
简述@weakify、@strongify

前言在开发中，经常在控制器中用到block语句，在block语句中如果需引用self，而self（控制器）对象中又持有block对象，就会造成循环引用循环引用，导致内存泄露，比如以下代码：self.block = ^{ [self test]; };一般我们是用一个__weal修饰的weakSelf变量指向self对象，在block中使用weakSelf:__weak typeof(self) weakSelf = self; self.bloc
复制链接

扫一扫