您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 程式開發 >> iOS 開發基礎

拆解 ReactiveCocoa 中的 @weakify 與 @strongify

編輯:iOS 開發基礎

先說問題

在 block 語句中若引用了 self,而 self 又持有這個 block,就會形成循環引用(retain cycle),導致洩漏:

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

常見解法是宣告一個 __weak 修飾的 weakSelf 指向 self,再在 block 裡用它:

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

但這樣寫仍可能出問題。weakSelf 是弱引用,一旦 self 被釋放,weakSelf 就會變成 nil。舉個例子,先定義一個帶 block 屬性的 TestObj:

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

@implementation TestObj
- (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

再在另一個類的 testFunc 方法中:

TestObj *obj = [TestObj new];
obj.block();

執行 testFunc,列印出來的卻是 (null)。原因在於 block 裡的列印是異步執行的,在 NSLog(@"%@", weakSelf); 真正執行之前,testFunc 就已經結束,obj 早已被釋放。

解法是在 block 內部對 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 消失,物件也就跟著釋放了。

問題在哪

這樣寫雖然嚴謹,但實在有點囉嗦。每次都要寫兩條長長的 __weak 和 __strong,而且 block 裡所有用到的 self 都得改成 strongSelf。如果要把一段大量使用 self 的程式碼貼進 block,一個個改是不是很煩?

RAC 怎麼解決

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

只要在 block 外寫 @weakify(self),在 block 內寫 @strongify(self),後續的 self 就能原封不動地照用,看起來頗為神奇。下面一起看看這兩個巨集最終被展開成了什麼。

導入 RAC 的標頭檔,把測試程式碼替換成 @weakify(self) 與 @strongify(self),在 Xcode 中開啟分屏、把右側顯示內容設為 Preprocess,就能看到巨集展開後的結果。

這裡有兩個細節值得注意:

  1. @autoreleasepool {} 是哪來的?留意 @weakify(self) 前面那個 @ 顏色並不是橙色,可見 @ 並不屬於巨集本身。你當然不能平白無故寫個 @,所以 RAC 在 weakify 的定義裡機智地補了一句 autoreleasepool {},一前一後剛好湊成一個什麼也沒做的 @autoreleasepool {}。
  2. __attribute__((objc_ownership(weak))) 又是什麼?這就是 __weak 在編譯前被編譯器替換後的樣子。weakify 最終會展開成 __weak,編譯器再換一次就成了這個屬性寫法。

weakify、strongify 的定義

預備知識

先看 ... 與 __VA_ARGS__。參考 NSLog、printf 這類函式,它們的參數個數不固定,用 ... 表示。NSLog 的定義是 NSLog(NSString *format, ...)。巨集裡也可以用 ... 表示多個參數,而 __VA_ARGS__ 就對應那部分參數。舉例來說,如果你嫌 NSLog 太醜,想自造一個 Zlog:

#define Zlog(...) NSLog(__VA_ARGS__)

再看 ##,它是巨集連接符,會把左右兩側連接起來。例如定義 #define XLink(n) x##n,意思就是把 x 和傳入的 n 接在一起:

int x1 = 1;
int x2 = 2;
int x3 = 3;

NSLog(@"%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)。這個巨集能把可變參數替換成參數個數:一個參數會被替換成 1,兩個參數會被替換成 2。所以 metamacro_argcount(self) 會變成 1。

再看 metamacro_concat 的定義:

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

繞了一層,本質就是前面提到的連接符 ##。所以 metamacro_concat(A, B) 就是把 A、B 接成 AB:

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

也就是:

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

第三層。沒錯,RAC 確實還定義了 metamacro_foreach_cxt1 這個帶數字後綴的巨集:

有 cxt1 自然就有 cxt2、3、4、5、6、7、8……,這些先不管,只看 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(obj1, obj2, ..., obj20) 最終會展開成:

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

RAC 的巨集是怎麼「裝」起來的

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_argcount(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:

又是一堆看似混亂的定義,其實看懂一個就全懂了:

#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。上面那串的前 20 個參數是 self, 20, 19, ..., 2,所以剩下的是 1。

那如果一開始傳兩個參數呢?比如 metamacro_argcount(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,於是呼叫 metamacro_head(2, 1)。看看它的定義:

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

也就是取第一個參數,所以 metamacro_head(2, 1) 得到 2,而 metamacro_head(1) 得到 1。其他 metamacro_atN 也是同一套邏輯。

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) 先確定參數個數為 3,於是對號入座呼叫 metamacro_foreach_cxt3:

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

它是個遞迴:

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

而 cxt2 又是一層遞迴,最終 obj1、obj2、obj3 都被替換成:

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

總結

其實就兩步:

  1. 用 metamacro_argcount 數出可變參數的個數 x。
  2. 依 x 呼叫 metamacro_foreach_cxtx,層層遞迴,對每個參數做巨集替換。
  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved