block本质探寻三之block类型

一、oc代码

提示：看本文章之前，最好按顺序来看；

//代码

void test1()
{
    int age = ;

    void(^block1)(void) = ^{
        NSLog(@"block1----");
    };

    void(^block2)(void) = ^{
        NSLog(@"block2----%d", age);
    };

    NSLog(@"block1-----\n%@ %@ %@ %@", [block1 class], [[block1 class] superclass], [[[block1 class] superclass] superclass], [[[[block1 class] superclass] superclass] superclass]);

    NSLog(@"block2-----\n%@ %@ %@ %@", [block2 class], [[block2 class] superclass], [[[block2 class] superclass] superclass], [[[[block2 class] superclass] superclass] superclass]);

    NSLog(@"block-----\n%@ %@ %@ %@", [^{
        NSLog(@"block----%d", age);
    } class], [[^{
        NSLog(@"block----%d", age);
    } class] superclass], [[[^{
        NSLog(@"block----%d", age);
    } class] superclass] superclass], [[[[^{
        NSLog(@"block----%d", age);
    } class] superclass] superclass] superclass]);
}

//打印

-- ::04.290317+ MJ_TEST[:] block1-----
__NSGlobalBlock__ __NSGlobalBlock NSBlock NSObject
-- ::04.290608+ MJ_TEST[:] block2-----
__NSMallocBlock__ __NSMallocBlock NSBlock NSObject
-- ::04.290652+ MJ_TEST[:] block-----
__NSStackBlock__ __NSStackBlock NSBlock NSObject
Program ended with exit code: 

分析：

1）三个block的类型分别为：__NSGlobalBlock__、__NSMallocBlock__、__NSStackBlock__，什么原因，往下看；

2）上述三种类型最终都是继承自NSBlock，而NSBlock又是继承自NSObject：此处又进一步说明block其实就是一个OC对象（前面的文章已经证明过）；

说明：上述结果是在ARC模式下打印的结果，现在我们看看MRC的打印情况

//设置

//打印

-- ::50.667948+ MJ_TEST[:] block1-----
__NSGlobalBlock__ __NSGlobalBlock NSBlock NSObject
-- ::50.668257+ MJ_TEST[:] block2-----
__NSStackBlock__ __NSStackBlock NSBlock NSObject
-- ::50.668279+ MJ_TEST[:] block-----
__NSStackBlock__ __NSStackBlock NSBlock NSObject
Program ended with exit code: 

分析：发现MRC模式下，三种block类型：__NSGlobalBlock__、__NSStackBlock__、__NSStackBlock__，为什么中间的类型由malloc变成了stack？这是因为ARC系统自动帮助我们对block进行了copy操作；

补充一下：clang成C++代码，我们看下

struct __test1_block_impl_0 {
  struct __block_impl impl;
  struct __test1_block_desc_0* Desc;
  __test1_block_impl_0(void *fp, struct __test1_block_desc_0 *desc, int flags=) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

struct __test1_block_impl_1 {
  struct __block_impl impl;
  struct __test1_block_desc_1* Desc;
  int age;
  __test1_block_impl_1(void *fp, struct __test1_block_desc_1 *desc, int _age, int flags=) : age(_age) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

struct __test1_block_impl_2 {
  struct __block_impl impl;
  struct __test1_block_desc_2* Desc;
  int age;
  __test1_block_impl_2(void *fp, struct __test1_block_desc_2 *desc, int _age, int flags=) : age(_age) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

分析：发现都是_NSConcreteStackBlock类型，不能正确反应block的实质类型（据说是LLVM编译器版本的问题，而clang又是LLVM的一部分）；

二、原因分析

1）程序内存结构

<1>首先，程序的内存结构分为：程序区（代码区）、数据区（全局区）、堆区、栈区；

<2>全局变量、static类型的局部变量存放在数据区，内存直到程序结束才自动释放；auto类型的局部变量、参数（形/实参）存放在栈区，离其最近的大阔结束时自动内存自动被释放；通过malloc\alloc\copy等手动开辟内存的，则存放在堆区，需要程序员手动予以释放；程序区可以看成非变量区，除变量外，程序的一些其他代码即常量存放在该区；

说明：

<1>除了堆区需要程序员手动管理内存外，其他区都由系统自动管理；

<2>等号左右：

{
        //等号左边：auto形局部变量，存放在栈区；等号右边：常量，存放在数据区；
        int age = ;
        //等号左边：auto形局部变量（指针），存放在栈区；等号右边：auto形局部变量地址，存放在栈区；
        int *agePtr = &age;
        //等号左边：auto形局部变量（指针），存放在栈区；等号右边：alloc开辟的对象，存放在堆区；
        NSObject *objc = [[NSObject alloc] init];
 }

2）block类型

<1>三种block类型（global、malloc、stack），从字面理解，可以推断依次存放在数据区、堆区、栈区；

<2>我们发现，blcok1没有访问任何变量，后两个block都访问量变量age，而age是一个auto类型的局部变量；似乎block的类型跟访问的变量有关系？往下看；

//代码

int weight = ;

void test2()
{
    static int age = ;

    void(^block1)(void) = ^{
        NSLog(@"-----%d", age);
    };

    void(^block2)(void) = ^{
        NSLog(@"-----%d", weight);
    };

    NSLog(@"%@ %@", [block1 class], [block2 class]);
}

//打印

-- ::56.366509+ MJ_TEST[:] __NSGlobalBlock__ __NSGlobalBlock__
Program ended with exit code: 

分析：

<1>如果age是static修饰的局部变量，或者访问全局变量，则block的类型都是__NSGlobalBlock__，那么我们基本上可以肯定，block的类型取决于其访问的变量的属性；

<2>这里带来了一个新的问题：

因为auto类型的局部变量是存放在栈区的，而block要访问该变量，经前述文章分析，block会讲该变量捕获到block结构体内部，即重新开辟内存来存放该局部变量（相当于copy操作，但不是copy），那么此时的block自己是存放在哪个区呢？

前面说了，auto类型的局部变量一定是存放在栈区的，这点毋庸置疑，而block虽然新开辟内存来存放该变量，但改变不了该变量是一个auto类型的局部变量的属性，因此此时的block也只能存放在栈区；

既然存放在栈区，则访问的变量作用域仅限于离其最近的大括号范围内，超出则被自动释放，我们来验证下

//代码

void(^block)(void);

void test3()
{
    int age = ;

    block = ^{
        NSLog(@"----%d", age);
    };
}

int main(int argc, const char * argv[]) {
    @autoreleasepool {
//        test1();
//        test2();
        test3();
        block();
    }
    return ;
}

//打印

-- ::19.489782+ MJ_TEST[:] -----
Program ended with exit code: 

分析：

<1>age是一个auto类型的局部变量，作用域仅限于test3()函数，该函数一旦调用完毕，age则被自动释放（变成垃圾内存，值不确定）；

<2>根据打印结果，age的值不是10而是一堆乱码，说明age已经被自动释放，block再次调用时，访问的是被废弃的内存；

那么如何才能不被自动释放？往下看

//代码

void test4()
{
    int age = ;

    block = [^{
        NSLog(@"----%d", age);
    } copy];
}

int main(int argc, const char * argv[]) {
    @autoreleasepool {
//        test1();
//        test2();
//        test3();
        test4();
        block();
        NSLog(@"%@", [block class]);

    }
    return ;
}

//打印

2019-01-11 09:37:16.563329+0800 MJ_TEST[776:26631] ----10

2019-01-11 09:37:16.563935+0800 MJ_TEST[776:26631] __NSMallocBlock__

Program ended with exit code: 0

分析：

<1>通过copy操作能达到auto类型的局部变量的值正确，为什么？因为copy是把age的值直接拷贝到了一块新的内存区域，而我们知道copy操作开辟的内存必定是在堆区（同时，block的类型由之前的__NSStackBlock__类型变为__NSMallocBlock__类型）；

<2>因此，防止一个auto类型的局部变量自动释放的方法，就是将其copy到堆区进行手动管理，达到对其生命周期可控的目的（所以记得要释放[block release]）——这是MRC模式下须手动管理内存，而在ARC模式下系统会自动管理内存（copy和release）；

说明：block此处的copy是深拷贝还是浅拷贝，以及深拷贝和浅拷贝的区别——后面文章会写到！

三、结论

1）blcok的类型取决于其访问的变量的类型，跟是否有强指针持有block对象无关（但ARC下，会从栈区拷贝到堆区）：

【1】global：没有访问auto类型局部变量——包括：没有访问任何变量、访问了static类型的局部变量、访问了全局变量（包括static和auto类型）；

【2】stack：访问了auto类型的局部变量；

【3】malloc：对block进行了copy操作；

2）存储位置：

GitHub