OC语言 - block：内存分布

copy | retain | release

1 - block 在内存中的存储状况分为 NSGlobalBlock、NSStackBlock 和 NSMallocBlock 三种

2 - 对于 block 而言，我们对 block 不管是 retain、copy、release 都不会改变其引用计数：retainCount 始终是 1。block_copy 和 copy 等效；block_release 和 release 等效

① NSMallocBlock 支持 retain、release！虽然 retainCount 始终是 1，但内存管理器中引用计数仍然会增加、减少。堆中的 block 进行 copy 后不会生成新的对象，只是增加了一次引用，相当于 retain

② NSGlobalBlock：retain、copy、release 操作都无效

③ NSStackBlock：retain、release 等操作无效，copy 除外！因为 NSStackBlock 在函数返回后其内存就被回收，即使把栈中的 block 使用 retain 也完全没任何用，但是栈区中的 block 经 copy 后会生成新的 NSMallocBlock 对象

注：尽量不要对 block 进行 retain 操作

3 - MRC 中容易犯的错误是 [[mutableAarry addObject:stackBlock] 原因在于当函数出栈后，从 mutableAarry 中取到的 stackBlock 已经被回收，会变成野指针。正确的做法是先将 stackBlock 拷贝到堆上，然后加入数组：[mutableAarry addObject:[[stackBlock copy] autorelease]]；如果是在 ARC 中就不用担心此问题，因为它会默认将实例化的 block 拷贝到堆上（后面会详细学习）

block 的内存分布

1 - MRC 环境

// - Student.h

 #import <Foundation/Foundation.h>
 @interface Student : NSObject
 @end

// - Student.m

 #import "Student.h"
 @implementation Student
 @end

// - main.m

#import <Foundation/Foundation.h>
#import "Student.h"
int main(int argc, const char * argv[]) {

    // ---------------- 测试一 ：block 内部不引用任何外部局部变量，位于全局静态区 --------------------
    void (^myBlock01)(void) = ^{
        NSLog(@"梦想总是遥不可及");
    };
    myBlock01();
    NSLog(@"%@",myBlock01);// __NSGlobalBlock__

    void (^myBlock02)(void) = ^{
        Student *stu01 = [[Student alloc] init];
        NSLog(@"%@",stu01);
    };
    myBlock02();
    NSLog(@"%@",myBlock02);// __NSGlobalBlock__

    static int c = 12;
    void (^myBlock10)(void) = ^{
        NSLog(@"%d",c);
    };
    myBlock10();
    NSLog(@"%@",myBlock10);// __NSGlobalBlock__


    // -------------------- 测试二：当在 block 内部引用外部变量的时，block 内存由全局静态区移到了栈区 --------------------
    int a = 10;
    void (^myBlock03)(void) = ^{
        NSLog(@"%d",a);
    };
    myBlock03();
    NSLog(@"%@",myBlock03);// __NSStackBlock__

    Student *stu02 = [[Student alloc] init];
    void(^myBlock04)(void) = ^(){
        NSLog(@"%@",stu02);
    };
    myBlock04();
    NSLog(@"%@ ",myBlock04);// __NSStackBlock__


    // -------------------- 测试三：对全局静态区的 block 进行 copy ，那么 block 依旧是全局静态区 --------------------
    void(^blockGlo)(void) = ^(){
        NSLog(@"globalBlock Copy");
    };
    NSLog(@"%@",blockGlo);// __NSGlobalBlock__
    NSLog(@"%@",Block_copy(blockGlo));// __NSGlobalBlock__


    // -------------------- 测试四：对栈区的 block 进行 copy，那么 block 会从栈区拷贝到了堆区 --------------------
    int b = 11;
    void (^myBlock05)(void) = ^{
        NSLog(@"%d",b);
    };
    NSLog(@"%@",myBlock05);// __NSStackBlock__
    NSLog(@"%@",Block_copy(myBlock05));// __NSMallocBlock__
    

    // -------------------- 测试五：当 block 内部引入变量是对象类型时，copy 操作会对该对象的引用计数加 1，这就要注意内存问题了 --------------------
    Student *stu05 = [[Student alloc] init]; // 1
    void(^myBlock06)(void) = ^{
        NSLog(@"%ld",stu05.retainCount); // 因 block 引用了外部对象 stu05，block 则在栈区
    };
    myBlock06();            // 这里 stu05 的引用计数是 1
    Block_copy(myBlock06);  // 经 copy 后 block 转移到了 堆区
    NSLog(@"%ld",stu05.retainCount);// 引用计数变成了 2
    
    /* 解决方案
        方案 ①：对对象使用 __block 修饰
        方案 ②：将堆区中的 block 进行 release 操作
     */

    Student *stu07 = [[Student alloc] init];
    // 方案 ①：简单高效
    // __block Student *stu07 = [[Student alloc] init];
    void(^myBlock08)(void) = ^{
        NSLog(@"stu07.retainCount = %ld",stu07.retainCount);
    };
    
    // 进行拷贝操作
    void(^myBlock09)(void) = Block_copy(myBlock08);
    myBlock09();
    // 如果使用了采取了方案 ① 使用 __block 修饰，这里 stu07.retainCount = 1
    // 否则 stu07.retainCount = 2
    
    // 方案 ②
    Block_release(myBlock09);
    myBlock09();    // stu07.retainCount = 1

    return 0;
}