iOS底層原理 - 探尋block本質(zhì) 之 __block

面試題引發(fā)的思考：

Q: __block的作用是什么？有什么使用注意點(diǎn)？

  • __block用于解決block內(nèi)部無法修改auto變量值的問題；
  • __block不能修飾全局變量、靜態(tài)變量。

Q: block內(nèi)部修改的NSMutableArray，是否需要添加__block？

  • 因?yàn)閎lock內(nèi)部只是使用了array的內(nèi)存地址添加數(shù)據(jù)，并沒有修改array的內(nèi)存地址，所以array不需要__block修飾；
  • 添加__block修飾符之后，系統(tǒng)會創(chuàng)建相應(yīng)的結(jié)構(gòu)體，占用一定的內(nèi)存空間；所以要根據(jù)相應(yīng)情況添加__block修飾符，避免內(nèi)存浪費(fèi)。

Q: 使用block有那些注意事項(xiàng)？

  • 注意循環(huán)引用問題。

iOS底層原理 - 探尋block本質(zhì)（二）中介紹到block對對象類型的變量捕獲，以及對象的銷毀時(shí)機(jī)。

下面介紹如何實(shí)現(xiàn)在block內(nèi)部修改變量的值。

1. 修飾符__block

需要在block內(nèi)部修改變量的值，代碼如下：

typedef void (^Block)(void);

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        int age = 10;
        Block block = ^{
            age = 20;  // error
        };
        block();
    }
    return 0;
}

以上代碼會出現(xiàn)編譯錯(cuò)誤。

C++源碼

通過源碼可知：
age是在main函數(shù)內(nèi)部聲明的變量，存在于main函數(shù)的棧空間內(nèi)部；
block內(nèi)部實(shí)現(xiàn)是__main_block_func_0函數(shù)，其內(nèi)部捕獲age，新增一個(gè)參數(shù)存儲外部的age變量的值，這個(gè)age存在于block的?？臻g內(nèi)部；
所以block內(nèi)部無法修改main函數(shù)內(nèi)部的auto變量。

Q: 那么該如何在block內(nèi)部修改變量的值呢？

1> 方法一：使用static變量
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        static int age = 10;
        Block block = ^{
            age = 20;
            NSLog(@"------------ %d", age);
            // 打印結(jié)果：------------ 20
        };
        block();
    }
    return 0;
}

由前文可知：局部變量都會被block捕獲，auto變量值傳遞，static變量指針傳遞。
block內(nèi)部會新增一個(gè)參數(shù)存儲age的指針，通過指針訪問age變量的內(nèi)存地址，就可以修改age的值。

2> 方法二：使用全局變量

全局變量在哪里都可以訪問，所以block不用捕獲全局變量，直接進(jìn)行訪問。

以上兩種方法會使變量一直存在于內(nèi)存中，占用內(nèi)存地址。我們可以使用__block修飾符來解決這個(gè)問題。

3> 方法三：使用__block修飾變量
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        __block int age = 10;
        Block block = ^{
            age = 20;
            NSLog(@"------------ %d", age);
            // 打印結(jié)果：------------ 20
        };
        block();
    }
    return 0;
}

轉(zhuǎn)化成C++源碼：

使用__block修飾變量的源碼

由源碼可知：

存值時(shí)：

  1. 被__block修飾的age變量會在block內(nèi)部轉(zhuǎn)化成名為age的__Block_byref_age_0結(jié)構(gòu)體，結(jié)構(gòu)體包括：

    • __isa：說明__Block_byref_age_0本質(zhì)也是對象
    • __flags：賦值為0
    • __forwarding：指向結(jié)構(gòu)體自身的指針
    • __size：占用的內(nèi)存空間
    • age：存儲變量

  2. 然后__Block_byref_age_0結(jié)構(gòu)體age存儲在結(jié)構(gòu)體__main_block_impl_0中。

取值時(shí)：

  1. 通過_cself->age將age賦值給 __Block_byref_age_0結(jié)構(gòu)體；
  2. age->__forwarding->age通過結(jié)構(gòu)體指針訪問成員變量來改變成員變量的值；
  3. 通過age->__forwarding->age進(jìn)行取值。
4> Q: 以下代碼是否可以正確執(zhí)行？
typedef void (^Block)(void);

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSMutableArray *array = [NSMutableArray array];
        Block block = ^{
            [array addObject: @"1"];
            [array addObject: @"2"];
            NSLog(@"array - %@", array);
        };
        block();
    }
    return 0;
}
  • 可以正確執(zhí)行。
  • 因?yàn)閎lock內(nèi)部只是使用了array的內(nèi)存地址添加數(shù)據(jù)，并沒有修改array的內(nèi)存地址；
  • 所以array不需要__block修飾；
  • 添加__block修飾符之后，系統(tǒng)會創(chuàng)建相應(yīng)的結(jié)構(gòu)體，占用一定的內(nèi)存空間；所以要根據(jù)相應(yīng)情況添加__block修飾符，避免內(nèi)存浪費(fèi)。

2. __block內(nèi)存管理

(1) 分析一下代碼：

typedef void (^Block)(void);

int main(int argc, const char * argv[]) {
    @autoreleasepool {

        int age = 10;
        __block int weight = 60;

        NSObject *object = [[NSObject alloc] init];
        __weak NSObject *weakObject = object;
        __block NSObject *blockObject = object;
        __block __weak NSObject *blockWeakObject = object;

        Block block = ^{
            NSLog(@"%d", age); // 局部變量
            NSLog(@"%d", weight); // __block修飾的局部變量
            NSLog(@"%p", object); // 對象類型的局部變量
            NSLog(@"%p", weakObject); // __weak修飾的對象類型的局部變量
            NSLog(@"%p", blockObject); // __block修飾的對象類型的局部變量
            NSLog(@"%p", blockWeakObject); // __block、__weak修飾的對象類型的局部變量
        };
        block();
     }
    return 0;
}

使用命令行xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc -fobjc-arc -fobjc-runtime=ios-8.0.0 main.m將代碼轉(zhuǎn)化成C++語言：

__main_block_impl_0函數(shù)

由__main_block_impl_0函數(shù)可知：

  1. 未使用__block修飾的變量（object、weakObject），根據(jù)被block捕獲的指針類型進(jìn)行強(qiáng)引用或弱引用；
  2. 使用__block修飾的變量（weight、blockObject、blockWeakObject），都是使用強(qiáng)指針引用生成的結(jié)構(gòu)體。
結(jié)構(gòu)體

由以上__block修飾的對象類型的變量生成的結(jié)構(gòu)體可知：

  1. 其內(nèi)部多了__Block_byref_id_object_copy和__Block_byref_id_object_dispose兩個(gè)函數(shù)，用來對對象類型的變量進(jìn)行內(nèi)存管理操作。
  2. block捕獲的對象類型決定結(jié)構(gòu)體對象的引用類型：
    a> blockObject是強(qiáng)指針，所以__Block_byref_ blockObject_1對blockObject就是強(qiáng)引用；
    b> blockWeakObject是弱指針，所以__Block_byref_ blockWeakObject_1對blockWeakObject就是弱引用。
__main_block_copy_0函數(shù)、__main_block_dispose_0函數(shù)

由以上C++代碼可知：

  1. __main_block_copy_0函數(shù)根據(jù)變量的強(qiáng)弱指針及是否被__block修飾做出不同處理：
    a> 強(qiáng)指針在block內(nèi)部產(chǎn)生強(qiáng)引用；
    b> 弱指針在block內(nèi)部產(chǎn)生弱引用；
    c> 被__block修飾的變量最后的參數(shù)傳入的是8；
    d> 沒有被__block修飾的變量最后的參數(shù)傳入的是3。
  2. __main_block_dispose_0函數(shù)會在block從堆中移除時(shí)釋放這些變量。

(2) 總結(jié)：

block復(fù)制到堆上

由block復(fù)制到堆上的內(nèi)存變化圖可知：

  1. 將block復(fù)制到堆上時(shí)，block內(nèi)部引用的__block變量也被復(fù)制到堆上，此時(shí)block持有__block變量；
  2. 若將block復(fù)制到堆上時(shí)，__block變量已經(jīng)在堆上，則不會再次將其復(fù)制到堆上。
block從堆上移除

由block從堆上移除的內(nèi)存變化圖可知：

  1. 將block從堆中移除時(shí)，若有別的block持有__block變量，則不會將__block變量移除；
  2. 將所有的block從堆中移除時(shí)，此時(shí)沒有block持有__block變量，__block變量被移除。

(3) __forwarding指針

typedef void (^Block)(void);

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        __block int age = 10;
        Block block = ^{
            age = 20;
        };
        block();
     }
    return 0;
}

將代碼轉(zhuǎn)化成C++語言：

C++代碼

由以上代碼可知：

  1. 當(dāng)block在棧上時(shí)，棧上的__Block_byref_age_0結(jié)構(gòu)體內(nèi)部__forwarding指針指向結(jié)構(gòu)體自己；
  2. 當(dāng)block復(fù)制到堆上時(shí)，棧上的__Block_byref_age_0結(jié)構(gòu)體也會被復(fù)制到堆上，此時(shí)棧上的__Block_byref_age_0結(jié)構(gòu)體內(nèi)部__forwarding指針指向的是堆中的__Block_byref_age_0結(jié)構(gòu)體，堆中__Block_byref_age_0結(jié)構(gòu)體內(nèi)的__forwarding指針依然指向自己。

以上結(jié)論可由下圖展示：

__forwarding指針

3. __block修飾的對象類型的內(nèi)存管理

(1) __block修飾對象類型

typedef void (^Block)(void);

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        __block Person *person = [[Person alloc] init];
        // __block __weak Person *person = [[Person alloc] init];
        Block block = ^ {
            NSLog(@"%p", person);
        };
        block();
     }
    return 0;
}

將代碼轉(zhuǎn)化成C++語言：

C++代碼

由以上C++代碼可知：
__Block_byref_person_0內(nèi)部多了__Block_byref_id_object_copy和__Block_byref_id_object_dispose兩個(gè)函數(shù)，用來對對象類型的變量進(jìn)行內(nèi)存管理操作：

對于__Block_byref_id_object_copy函數(shù)：
a> __Block_byref_id_object_copy函數(shù)賦值為__Block_byref_id_object_copy_131函數(shù)；
b> __Block_byref_id_object_copy_131函數(shù)調(diào)用_Block_object_assign函數(shù)；
c> _Block_object_assign函數(shù)內(nèi)部拿到dst指針(block對象的地址值)加上40個(gè)字節(jié)，即為person指針。

也就是說__Block_byref_id_object_copy函數(shù)會將person地址傳入_Block_object_assign函數(shù)，_Block_object_assign中對Person對象進(jìn)行強(qiáng)引用或者弱引用。】

__Block_byref_id_object_copy函數(shù)同理。

(2) __block、__weak同時(shí)修飾對象類型

使用__block、__weak同時(shí)修飾變量同理。

即block內(nèi)部對__block修飾變量生成的結(jié)構(gòu)體都是強(qiáng)引用；
結(jié)構(gòu)體內(nèi)部對外部變量的引用取決于傳入block內(nèi)部的變量是強(qiáng)引用還是弱引用。

(3) 總結(jié)

  • 當(dāng)block在棧上時(shí)，不會對__block變量產(chǎn)生強(qiáng)引用；

  • 當(dāng)block被copy到堆時(shí)：
    a> 會調(diào)用block內(nèi)部的copy函數(shù)；
    b> copy函數(shù)內(nèi)部會調(diào)用_Block_object_assign函數(shù)；
    c> _Block_object_assign函數(shù)會根據(jù)所指向?qū)ο蟮男揎椃?code>__strong、__weak、__unsafe_unretained）做出相應(yīng)的操作，形成強(qiáng)引用（retain）或者弱引用（注意：這里僅限于ARC時(shí)會retain，MRC時(shí)不會retain）。

  • 當(dāng)block從堆中移除時(shí)：
    a> 會調(diào)用block內(nèi)部的dispose函數(shù)；
    b> dispose函數(shù)內(nèi)部會調(diào)用_Block_object_dispose函數(shù)；
    c> _Block_object_dispose函數(shù)會自動釋放指向的對象（release）。

4. 循環(huán)引用

(1) 循環(huán)引用原理

// TODO: -----------------  Person類  -----------------
typedef void (^Block)(void);

@interface Person : NSObject
@property (nonatomic, assign) int age;
@property (nonatomic, copy) Block myBlock;
@end

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

// TODO: -----------------  main  -----------------
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Person *person = [[Person alloc] init];
        person.age = 10;
        person.myBlock = ^{
            NSLog(@"%d", person.age);
        };
     }
    NSLog(@"大括號已經(jīng)結(jié)束");
    return 0;
}

// 打印結(jié)果
Demo[1234:567890] 大括號已經(jīng)結(jié)束

由打印結(jié)果可知：
大括號已經(jīng)結(jié)束，person沒有被釋放，產(chǎn)生了循環(huán)引用。

循環(huán)引用原理

循環(huán)引用原理如上圖所示：
大括號結(jié)束后引用1被斷開，引用2與引用3沒有斷開，形成循環(huán)引用，進(jìn)而造成內(nèi)存泄漏。

(2) 循環(huán)引用解決方法 - ARC

解決循環(huán)引用問題，還需要保證block在person銷毀前不被銷毀，解決方案是：
Person對block的引用(引用2)為強(qiáng)引用；block內(nèi)部對Person的引用(引用3)為弱引用。

1> 使用__weak和__unsafe_unretained修飾符
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Person *person = [[Person alloc] init];
        person.age = 10;

        // __weak：不會產(chǎn)生強(qiáng)引用，指向?qū)ο箐N毀時(shí)，會自動讓指針置為nil
        // __unsafe_unretained：不會產(chǎn)生強(qiáng)引用，不安全，指向?qū)ο箐N毀時(shí)，指針存儲的地址值不變

        //  __weak Person *weakPerson = person;
        // __weak typeof(person) weakPerson = person;
        __unsafe_unretained typeof(person) weakPerson = person;
        person.myBlock = ^{
            NSLog(@"age - %d", weakPerson.age);
        };
    }
    NSLog(@"大括號已經(jīng)結(jié)束");
    return 0;
}
2> 使用__block修飾符
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        __block Person *person = [[Person alloc] init];
        person.age = 10;
        person.myBlock = ^{
            NSLog(@"age - %d", person.age);
            person = nil;
        };
        person.myBlock();
    }
    NSLog(@"大括號已經(jīng)結(jié)束");
    return 0;
}

使用__block修飾符打破循環(huán)引用原理如下：

__block修飾符打破循環(huán)引用

由上文可知：
__block修飾person變量，會生成__Block_byref_person_0結(jié)構(gòu)體，其內(nèi)部包含的person對象才是block內(nèi)部使用的變量。

那么將block內(nèi)部的person置為nil，三角循環(huán)引用就會斷開。

此方法要求執(zhí)行block，并且在block內(nèi)部將person對象置為nil。

(2) 循環(huán)引用解決方法 - MRC

1> 使用__unsafe_unretained修飾符
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        __unsafe_unretained Person *person = [[Person alloc] init];
        person.age = 10;
        person.myBlock = [^{
            NSLog(@"age - %d", person.age);
        } copy];
        [person release];
    }
    NSLog(@"大括號已經(jīng)結(jié)束");
    return 0;
}

MRC環(huán)境下不支持__weak修飾符，使用__unsafe_unretained修飾符原理同ARC環(huán)境下相同，不再贅述。

2> 使用__block修飾符
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        __block Person *person = [[Person alloc] init];
        person.age = 10;
        person.myBlock = [^{
            NSLog(@"age - %d", person.age);
        } copy];
        [person release];
    }
    NSLog(@"大括號已經(jīng)結(jié)束");
    return 0;
}

由上文可知：
MRC環(huán)境下，當(dāng)block被copy到堆時(shí)，__block結(jié)構(gòu)體不會對person產(chǎn)生強(qiáng)引用，所以也可以解決循環(huán)引用問題。

最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時(shí)請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點(diǎn)，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容