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

從記憶體視角真正看懂 Block 與 Closure 的循環引用

編輯:iOS 開發基礎

前言

這篇不打算從頭講 Block(閉包)怎麼用,網路上這類教學已經很多。真正想談的是那個反覆咬人的老問題:循環引用。我很長一段時間只知道要寫 __weak,卻始終不明白 __strong 到底有什麼存在意義,直到親手踩進坑裡才頓悟。之前的文章提過這個話題,但只停在「怎麼寫」,沒講「為什麼」。這次我們把道理拆開來看。

本文涵蓋:OC 中 Block 的循環引用、單用 __weak、__weak 與 __strong 搭配使用,以及 Swift 閉包的對應解法。

一、OC 中 Block 的循環引用

先建一個 LRShop 類別,裡面有兩個屬性:

@property (nonatomic, copy) NSString *string;
@property (nonatomic, copy) void (^myBlock)();

從最基礎的寫法開始:

LRShop *shop = [[LRShop alloc] init];
shop.string = @"welcome to our company";
shop.myBlock = ^{
    NSLog(@"%@", shop.string);
};
shop.myBlock();

關鍵點:block 內部使用了外部的強引用物件 shop,編譯器會為 block 悄悄產生一個強引用指向 shop。於是 shop 永遠不會被釋放,循環引用就此成立。

圖中每一條橘線都是強引用:shop 指向 LRShop 物件,myBlock 指向 block,string 指向字串常數,最後 block 又回頭指向 LRShop 物件,閉環完成。

__weak 的用法

第一個解法当然是 __weak。這裡先宣告一個自用巨集:

#define LRWeakSelf(type) __weak typeof(type) weak##type = type;

LRWeakSelf(shop);
shop.myBlock = ^{
    NSLog(@"%@", weakshop.string);
};
shop.myBlock();

在 block 外部宣告一個弱引用,block 內部捕獲它時也只會產生弱引用,閉環被打斷。

歸納出一條規律:block 內部使用外部物件時,外部是強引用,內部就產生強引用;外部是弱引用,內部就產生弱引用。如果還是有點模糊,再看一個例子:

self.myName = @"我的名字是傑克!";
LRShop *shop = [[LRShop alloc] init];
shop.myBlock = ^{
    NSLog(@"%@", self.myName);
};
shop.myBlock();

這裡會循環引用嗎?不會。self.myName 是 ViewController 的屬性,block 內部對它產生強引用,但 self.myName 並沒有強引用 block。用比喻說:粉絲(block)單方面追求明星(self.myName),粉絲再熱情,明星也愛答不理,所以不會互相鎖死。

二、__weak 與 __strong 搭配使用

#define LRWeakSelf(type) __weak typeof(type) weak##type = type;
#define LRStrongSelf(type) __strong typeof(type) type = weak##type;

LRShop *shop = [[LRShop alloc] init];
shop.string = @"welcome to our company";
LRWeakSelf(shop);
shop.myBlock = ^{
    LRStrongSelf(shop)
    NSLog(@"%@", shop.string);
};
shop.myBlock();

表面上「外面弱、裡面強」,看起來像沒寫。但要理解一件事:LRStrongSelf(shop) 宣告的是 block 內部的強引用,不是外部那個。它是 block 執行期間才誕生的區域變量,因此不會回頭影響外部物件,也不會讓外部自動產生強引用。所以既沒有循環引用,又能正常讀到 shop.string——好像跟只用 __weak 沒差別?接著看這段:

只用 LRWeakSelf,並在 block 內延遲兩秒再輸出,問題就出現了:物件確實被釋放了,但印出來的值是 null。

LRWeakSelf(shop);
shop.myBlock = ^{
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)),
                dispatch_get_main_queue(), ^{
        NSLog(@"%@", weakshop.string);
    });
};
shop.myBlock();

若 weak 與 strong 一起使用,輸出就有值,而且物件最後仍然被釋放:

LRWeakSelf(shop);
shop.myBlock = ^{
    LRStrongSelf(shop)
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)),
                dispatch_get_main_queue(), ^{
        NSLog(@"%@", shop.string);
    });
};
shop.myBlock();

為什麼?把記憶體關係拆成逐步來看:

建立階段:

  1. 執行 LRShop *shop = [[LRShop alloc] init],產生第 1 條強引用,指向 LRShop 物件。
  2. 執行 LRWeakSelf(shop),產生第 2 條弱引用指向同一物件(圖中第 3 條可先忽略)。
  3. 執行 shop.myBlock = ^{...},產生第 4 條強引用,由 shop 指向 block。
  4. 執行 shop.myBlock() 進入 block,執行到 LRStrongSelf(shop) 時,先自動產生第 5 條弱引用(外部是弱引用,內部就補一條弱引用),接著才產生第 6 條強引用指向 LRShop 物件。
  5. 執行 dispatch_after,GCD 內部產生第 7 條強引用持有這個 block。
  6. 因為 GCD 的 block 裡用到了外部強引用 shop,於是產生第 8 條強引用指向 LRShop 物件。

釋放階段:

  1. dispatch_after 的 block 延遲兩秒且不阻塞線程,任務立刻往下走。shop.myBlock 的大括號執行完,區域變量 LRStrongSelf(shop) 隨即銷毀,第 6 條線消失。
  2. viewDidLoad 的大括號也執行完,shop 與 weakshop 這兩個區域變量銷毀,第 1、2 條線一起消失。
  3. 此時只剩 GCD 的第 8 條強引用還抓著 LRShop 物件,所以物件沒死。兩秒後 block 執行,因為物件還活著,輸出自然有值;接著 GCD 釋放 block,第 7 條線消失、第 8 條線跟著消失,再無人持有 LRShop 物件,全部收尾。

這就是 weak 加 strong 的真正意義:它不是在解循環引用,而是在「非同步執行期間把物件續命」,確保 block 真正跑完之前物件不會先走一步。

三、Swift 閉包的三種解法

寫法一,weak var:

let shop: LRShop = LRShop()
weak var weakShop = shop
shop.myBlock = { (str: String) -> () in
    weakShop?.string = str
    print((weakShop?.string)!)
}
shop.myBlock!(str: "哈囉,你好!")

實務上很少這樣寫,太囉嗦。

寫法二,[unowned shop]:

let shop: LRShop = LRShop()
shop.myBlock = {[unowned shop] (str: String) -> () in
    shop.string = str
    print(shop.string!)
}
shop.myBlock!(str: "哈囉,你好!")

能解循環引用,但很危險:物件若先釋放,這裡會直接崩潰。

寫法三,[weak shop],也就是最常見的 [weak self]:

let shop: LRShop = LRShop()
shop.myBlock = {[weak shop] (str: String) -> () in
    shop?.string = str
    print((shop?.string)!)
}
shop.myBlock!(str: "哈囉,你好!")

三種寫法都能解掉循環引用,deinit(等同 OC 的 dealloc)都會被正常呼叫。

既然 weak 就夠了,那 Swift 裡延遲兩秒的場景怎麼辦?Swift 沒有 strong 關鍵字:

let shop: LRShop = LRShop()
shop.myBlock = {[weak shop] (str: String) -> () in
    let time: NSTimeInterval = 2.0
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, Int64(time * Double(NSEC_PER_SEC))),
        dispatch_get_main_queue()) {
        shop?.string = str
        print((shop?.string))
    }
}
shop.myBlock!(str: "哈囉,你好!")

我的想法很直接:既然缺一個強引用,那就在 block 內部自己宣告一個:

let strongShop = shop;

完整寫法:

let shop: LRShop = LRShop()
shop.myBlock = {[weak shop] (str: String) -> () in
    // 在閉包內部建立強引用,為非同步任務續命
    let strongShop = shop
    let time: NSTimeInterval = 2
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, Int64(time * Double(NSEC_PER_SEC))),
        dispatch_get_main_queue()) {
        strongShop?.string = str
        print((strongShop?.string)!)
    }
}
shop.myBlock!(str: "哈囉,你好!")

不論 OC 還是 Swift,我們都優雅地解掉了 block(閉包)的循環引用,也看清了循環引用在記憶體上的真實樣子。Swift 這部分若有更好的寫法,歡迎前輩指正。

  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved