block的本质1

问题

block的原理是怎样的？本质是什么？
__block的作用是什么？有什么使用注意点？
block的属性修饰词为什么是copy？使用block有哪些使用注意？
block在修改NSMutableArray，需不需要添加__block？

block本质上也是一个OC对象，他内部也有一个isa指针。block是封装了函数调用以及函数调用环境的OC对象。

1. `block`的底层结构

首先写一个简单的block

int age = 10;
void(^block)(int, int) = ^(int a, int b) {
    NSLog(@"this is block,a = %d,b = %d",a,b);
    NSLog(@"this is block,age = %d",age);
};
block(3, 5);

使用命令行将代码转化为c++查看其内部结构：

xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m

底层的c++代码如下所示：

int age = 10;

// 定义block变量
void(*block)(int, int) = ((void (*)(int, int))&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, age));

// 调用block
((void (*)(__block_impl *, int, int))((__block_impl *)block)->FuncPtr)((__block_impl *)block, 3, 5);

上述代码中，可以发现，在block定义其实是使用了__main_block_impl_0函数来初始化，并且将__main_block_impl_0函数的地址赋值给了名称block，紧接着来看一下__main_block_impl_0函数的内部结构。

1.1 底层`block`的声明

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int age;
  // 构造函数，相当于初始化，返回自己结构体
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _age, int flags=0) : age(_age) {
    // block类型
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    // 函数地址
    impl.FuncPtr = fp;
    // 结构体大小信息
    Desc = desc;
  }
};

__main_block_imp_0底层是一个结构体，它内部有一个同名构造函数__main_block_imp_0，构造函数中对一些变量进行了赋值最终会返回一个结构体。

那么也就是说最终将一个__main_block_imp_0结构体的地址赋值给了block变量。

__main_block_impl_0结构体内可以发现给__main_block_impl_0构造函数中传入了四个参数：

(void *)__main_block_func_0
&__main_block_desc_0_DATA
age
flags

其中flage有默认值，也就说flage参数在调用的时候可以省略不传，如果传了那就使用传递的值。

接下来看一下前面每个参数分别代表什么：

参数1：`(void *)__main_block_func_0`

static void __main_block_func_0(struct __main_block_impl_0 *__cself, int a, int b) {
  // 取出block中的age值
  int age = __cself->age; // bound by copy

    // block里面的代码
    NSLog((NSString *)&__NSConstantStringImpl__var_folders_jp_wpw4tlhn0qn91rgns6wx4dh00000gn_T_main_b19af1_mi_0,a,b);
    NSLog((NSString *)&__NSConstantStringImpl__var_folders_jp_wpw4tlhn0qn91rgns6wx4dh00000gn_T_main_b19af1_mi_1,age);
}

在__main_block_func_0函数中首先取出block中age的值，紧接着可以看到两个熟悉的NSLog，可以发现这两段代码恰恰是我们在block块中写下的代码。那么__main_block_func_0函数中其实存储着我们block中写下的代码。

而__main_block_impl_0函数中传入的是(void *)__main_block_func_0，也就说将我们写在block块中的代码封装成__main_block_func_0函数，并将__main_block_func_0函数的地址传入了__main_block_impl_0的构造函数中保存在结构体内。

参数2：`&__main_block_desc_0_DATA`

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};

我们可以看到结构体__main_block_desc_0中存储着两个参数，reserved和Block_size，并且reserved赋值为0，而Block_size则存储着__main_block_impl_0的占用空间大小。最终将__main_block_desc_0结构体的地址传入__main_block_func_0中赋值给Desc。

参数3：`age`

age也就是我们定义的局部变量。因为在block块中使用到age局部变量，所以在block声明的时候这里才会将age作为参数传入，也就说block会捕获age，如果没有在block中使用age，这里将只会传入(void *)__main_block_func_0，&__main_block_desc_0_DATA两个参数。

这里可以根据源码思考一下为什么当我们在定义block之后修改局部变量age的值，在block调用的时候无法生效。

int age = 10;
void(^block)(int, int) = ^(int a, int b) {
    NSLog(@"this is block,a = %d,b = %d",a,b);
    NSLog(@"this is block,age = %d",age);
};
age = 20;
block(3, 5);

因为block在定的之后已经将age的值传入存储在__main_block_imp_0结构体中并在调用的时候将age从block中取出来使用，因此在block定义之后对局部变量进行改变是无法被block捕获的。

总结`__main_block_impl_0`结构体

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int age;
  // 初始化
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _age, int flags=0) : age(_age) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp; // 存储block代码块的地址
    Desc = desc; // 存储block对象占用内存大小
  }
};

首先我们看一下__main_block_impl_0第一个成员变量就是__block_impl结构体。
来到__block_impl结构体内部：

struct __block_impl {
  void *isa;
  int Flags;
  int Reserved;
  void *FuncPtr;
};

我们可以发现__block_impl结构体内部就有一个isa指针。因此可以证明block本质上就是一个oc对象。而在构造函数中将函数中传入的值分别存储在__main_block_impl_0结构体成员变量中，最终将__main_block_impl_0结构体实例的地址赋值给变量block。

接着通过上面对__main_block_impl_0结构体构造函数三个参数的分析我们可以得出结论：

__block_impl结构体中isa指针存储着&_NSConcreteStackBlock地址，可以暂时理解为其类对象地址，block就是_NSConcreteStackBlock类型的。
block代码块中的代码被封装成__main_block_func_0函数，FuncPtr则存储着__main_block_func_0函数的地址。
Desc指向__main_block_desc_0结构体对象，其中存储了__main_block_impl_0结构体实例多所占用的内存大小。

验证`block`的本质确实是`__main_block_impl_0`结构体类型。

通过代码证明一下上述内容：
同样使用之前的方法，我们按照上面分析的block内部结构自定义结构体，并将block内部的结构体强制转化为自定义的结构体，转化成功说明底层结构体确实如我们之前分析的一样。

struct __main_block_desc_0 {
    size_t reserved;
    size_t Block_size;
};
struct __block_impl {
    void *isa;
    int Flags;
    int Reserved;
    void *FuncPtr;
};
// 模仿系统__main_block_impl_0结构体
struct __main_block_impl_0 {
    struct __block_impl impl;
    struct __main_block_desc_0* Desc;
    int age;
};

int main(int argc, char * argv[]) {
    
    NSString * appDelegateClassName;
    
    @autoreleasepool {
        
        int age = 10;
        void(^block)(int, int) = ^(int a, int b) {
            NSLog(@"this is block,a = %d,b = %d",a,b);
            NSLog(@"this is block,age = %d",age);
        };
        age = 20;
        
        // 将底层的结构体强制转化为我们自己写的结构体，通过我们自定义的结构体探寻block底层结构体
        struct __main_block_impl_0 *blockStruct = (__bridge struct __main_block_impl_0 *)block;
        
        block(3, 5);
        
        appDelegateClassName = NSStringFromClass([AppDelegate class]);
    }
    return UIApplicationMain(argc, argv, nil, appDelegateClassName);
}

通过打断点可以看出我们自定义的结构体可以被赋值成功，以及里面的值。

block_customstrcut

接下来断点来到block代码块中，看一下堆栈信息中的函数调用地址。Debuf workflow -> always show Disassembly

block_stackmemory

通过上图可以看到地址确实和FuncPtr中的代码块地址一样。

1.2 底层调用`block`

((void (*)(__block_impl *, int, int))((__block_impl *)block)->FuncPtr)((__block_impl *)block, 3, 5);

通过上述代码可以发现调用block，是通过block找到FunPtr直接调用，通过上面分析我们知道block指向的是__main_block_impl_0类型结构体，但是我们发现__main_block_impl_0结构体中并不能直接就可以找到FunPtr，而FunPtr是存储在其第一个成员变量__block_impl中的，为什么block可以直接调用__block_impl中的FunPtr，而不是先找到__block_impl，再通过__block_impl找到FunPtr？

重新查看上述源代码可以发现，(__block_impl *)block将block强制转化为__block_impl类型的，因为__block_impl是__main_block_impl_0结构体的第一个成员，而__main_block_impl_0结构体的的地址就是自己第一个成员的地址，那么也就说明__block_impl的内存地址就是__main_block_impl_0结构的地址。所以可以转化成功。并找到FunPtr成员。

上面我们知道，FunPtr中存储着通过代码块封装的函数地址，那么调用此函数，也就是会执行代码块中的代码。并且回头查看__main_block_func_0函数，可以发现第一个参数就是__main_block_impl_0类型的指针。也就是说将block传入__main_block_func_0函数中，便于从中取出block捕获的值。

1.3 总结

此时已经基本对block的底层结构有了基本的认识，上述代码可以通过一张图展示其中各个结构体之间的关系。

block底层的数据结构也可以通过一张图来展示

2. `block`捕获变量的原理

为了保证block内部能够正常访问外部的变量，block有变量捕获机制，捕获的变量分为：

局部变量
全局变量

2.1 局部变量

`auto`变量

上述代码中我们已经了解过block对age变量的捕获。

auto自动变量，离开作用域就销毁，局部变量前面自动添加auto关键字。auto变量会被捕获到block内部，也就是说block内部会专门新增加一个参数来存储auto变量的值。

auto只存在于局部变量中，访问方式为值传递，通过上述对age参数的解释我们也可以确定确实是值传递。所以block内部访问的变量其实和外边的变量是相互独立的。

`static`变量

static修饰的变量为指针传递，同样会被block捕获。

接下来分别添加auto修饰的局部变量和static修饰的局部变量，重看源码来看一下他们之间的差别。

auto int a = 10;
static int b = 11;
void(^block)(void) = ^{
    NSLog(@"hello, a = %d, b = %d", a,b);
};
a = 1;
b = 2;
block();
// 输出：hello, a = 10, b = 2  
// block中a的值没有被改变而b的值随外部变化而变化。

重新生成c++代码看一下内部结构中两个参数的区别。

struct __main_block_impl_1 {
  struct __block_impl impl;
  struct __main_block_desc_1* Desc;
  int a; // a为值
  int *b; // b为指针
  
  // 参数：int _a, int *_b
  __main_block_impl_1(void *fp, struct __main_block_desc_1 *desc, int _a, int *_b, int flags=0) : a(_a), b(_b) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_1(struct __main_block_impl_1 *__cself) {
    
    // 获取a的值
  int a = __cself->a; // bound by copy
  // 获取b的值，类型是指针 int *
  int *b = __cself->b; // bound by copy

                // 获取b的值通过(*b)获取
                NSLog((NSString *)&__NSConstantStringImpl__var_folders_jp_wpw4tlhn0qn91rgns6wx4dh00000gn_T_main_2d5957_mi_2, a,(*b));
            }

static struct __main_block_desc_1 {
  size_t reserved;
  size_t Block_size;
} __main_block_desc_1_DATA = { 0, sizeof(struct __main_block_impl_1)};
int main(int argc, char * argv[]) {

    NSString * appDelegateClassName;

    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 

            auto int a = 10;
            static int b = 11;
            // 在block声明的时候会将b的地址作为参数传递
            void(*block)(void) = ((void (*)())&__main_block_impl_1((void *)__main_block_func_1, &__main_block_desc_1_DATA, a, &b));
            a = 1;
            b = 2;
            ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);


        appDelegateClassName = NSStringFromClass(((Class (*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("AppDelegate"), sel_registerName("class")));
    }
    return UIApplicationMain(argc, argv, __null, appDelegateClassName);
}

从上述源码中可以看出，a、b两个变量都有被捕获到block内部。但是变量a传入的是值，而变量b传入的则是地址。

为什么两种变量会有这种差异呢?

因为auto自动变量可能会销毁，block在执行的时候有可能自动变量已经被销毁了，那么此时如果再去访问被销毁的地址肯定会发生坏内存访问，因此对于auto自动变量一定是通过值传递的方式访问。

而static静态变量不会被销毁，所以完全可以传递地址。而因为传递的是值的地址，所以在block调用之前修改地址中保存的值，block中的地址是不会变得。所以值会随之改变。

2.2 全局变量

我们同样以底层源代码的方式看一下block是否会捕获全局变量

// block捕获全局变量
int a = 10; // auto变量
static int b = 11; // static变量

void(^block)(void) = ^{
    NSLog(@"hello, a = %d, b = %d", a,b);
};
a = 1;
b = 2;
block();
// 输出：hello, a = 1, b = 2

同样生成c++代码查看全局变量调用方式:

struct __main_block_impl_2 {
  // 结构体中没有a，b成员变量
  struct __block_impl impl;
  struct __main_block_desc_2* Desc;
  __main_block_impl_2(void *fp, struct __main_block_desc_2 *desc, int flags=0) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_2(struct __main_block_impl_2 *__cself) {

                // 直接访问全局变量a，b
                NSLog((NSString *)&__NSConstantStringImpl__var_folders_jp_wpw4tlhn0qn91rgns6wx4dh00000gn_T_main_b1571a_mi_3, a,b);
            }

static struct __main_block_desc_2 {
  size_t reserved;
  size_t Block_size;
} __main_block_desc_2_DATA = { 0, sizeof(struct __main_block_impl_2)};
int main(int argc, char * argv[]) {

    NSString * appDelegateClassName;

    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 

            void(*block)(void) = ((void (*)())&__main_block_impl_2((void *)__main_block_func_2, &__main_block_desc_2_DATA));
            a = 1;
            b = 2;
            ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);


        appDelegateClassName = NSStringFromClass(((Class (*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("AppDelegate"), sel_registerName("class")));
    }
    return UIApplicationMain(argc, argv, __null, appDelegateClassName);
}

通过上述代码可以发现，__main_block_imp_2并没有添加任何变量，因此block不需要捕获全局变量，因为全局变量无论在哪里都可以访问。

最后以一张图做一个总结

block_findvar

总结：局部变量都会被block捕获，auto自动变量是值捕获，static静态变量为地址捕获。全局变量则不会被block捕获

局部变量因为跨函数访问，所以需要捕获。全局变量在哪里都可以访问，所以不用捕获。

2.3 疑问：以下代码中`block`是否会捕获变量呢？

#import "Person.h"

@implementation Person
- (void)test {
    void(^block)(void) = ^{
        NSLog(@"%@",self);
    };
    block();
}

- (instancetype)initWithName:(NSString *)name {
    if (self = [super init]) {
        self.name = name;
    }
    return self;
}

+ (void)test2 {
    NSLog(@"类方法test2");
}
@end

同样转化为c++代码查看其底层内部结构:

struct __Person__test_block_impl_0 {
  struct __block_impl impl;
  struct __Person__test_block_desc_0* Desc;
  Person *self; // self变量被捕获
  __Person__test_block_impl_0(void *fp, struct __Person__test_block_desc_0 *desc, Person *_self, int flags=0) : self(_self) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __Person__test_block_func_0(struct __Person__test_block_impl_0 *__cself) {
  Person *self = __cself->self; // 取出block中self的值

        NSLog((NSString *)&__NSConstantStringImpl__var_folders_jp_wpw4tlhn0qn91rgns6wx4dh00000gn_T_Person_1f0e92_mi_0,self);
    }
static void __Person__test_block_copy_0(struct __Person__test_block_impl_0*dst, struct __Person__test_block_impl_0*src) {_Block_object_assign((void*)&dst->self, (void*)src->self, 3/*BLOCK_FIELD_IS_OBJECT*/);}

static void __Person__test_block_dispose_0(struct __Person__test_block_impl_0*src) {_Block_object_dispose((void*)src->self, 3/*BLOCK_FIELD_IS_OBJECT*/);}

static struct __Person__test_block_desc_0 {
  size_t reserved;
  size_t Block_size;
  void (*copy)(struct __Person__test_block_impl_0*, struct __Person__test_block_impl_0*);
  void (*dispose)(struct __Person__test_block_impl_0*);
} __Person__test_block_desc_0_DATA = { 0, sizeof(struct __Person__test_block_impl_0), __Person__test_block_copy_0, __Person__test_block_dispose_0};

// test方法默认传递两个参数：self 和 _cmd
// self作为参数传递给了block的声明构造函数
static void _I_Person_test(Person * self, SEL _cmd) {
    void(*block)(void) = ((void (*)())&__Person__test_block_impl_0((void *)__Person__test_block_func_0, &__Person__test_block_desc_0_DATA, self, 570425344));
    ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
}

从上面的底层源码中可以发现，self同样被block捕获，说明self是个局部变量，接着我们找到test方法可以发现，test方法默认传递了两个参数self和_cmd。而类方法test2也同样默认传递了两个参数：类对象self和方法选择器_cmd。

static void _C_Person_test2(Class self, SEL _cmd) {
    NSLog((NSString *)&__NSConstantStringImpl__var_folders_jp_wpw4tlhn0qn91rgns6wx4dh00000gn_T_Person_1f0e92_mi_1);
}

不论对象方法还是类方法都会默认将sel作为参数传递给方法内部，既然是作为参数传入，那么self肯定是局部变量。上面讲到局部变量肯定会被block捕获。

接着我们来看一下如果在block中使用成员变量或者调用实例的属性会有什么不同的结果。

- (void)test {
    void(^block)(void) = ^{
        NSLog(@"%@",self.name);
        NSLog(@"%@",_name);
    };
    block();
}

struct __Person__test_block_impl_0 {
  struct __block_impl impl;
  struct __Person__test_block_desc_0* Desc;
  Person *self; // 同样只捕获了self
  __Person__test_block_impl_0(void *fp, struct __Person__test_block_desc_0 *desc, Person *_self, int flags=0) : self(_self) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __Person__test_block_func_0(struct __Person__test_block_impl_0 *__cself) {
  Person *self = __cself->self; // bound by copy


        // ((NSString *(*)(id, SEL))(void *)objc_msgSend)((id)self, sel_registerName("name")))
        // self.name 调用了get方法，直接通过方法方法选择器SEL获取
        NSLog((NSString *)&__NSConstantStringImpl__var_folders_jp_wpw4tlhn0qn91rgns6wx4dh00000gn_T_Person_25279f_mi_0,((NSString *(*)(id, SEL))(void *)objc_msgSend)((id)self, sel_registerName("name")));
        
        // (*(NSString * _Nonnull *)((char *)self + OBJC_IVAR_$_Person$_name)))
        // _name 直接通过地址获取
        NSLog((NSString *)&__NSConstantStringImpl__var_folders_jp_wpw4tlhn0qn91rgns6wx4dh00000gn_T_Person_25279f_mi_1,(*(NSString * _Nonnull *)((char *)self + OBJC_IVAR_$_Person$_name)));
    }

可以发现，即使block中使用的是实例对象的属性，block中捕获的仍然是实例对象。

self.name通过get方法获取，直接通过runtime的objc_msgSend消息发送机制获取值。成员变量_age直接通过通过指针访问

3. `block`的类型

block对象是什么类型的，之前稍微提到过，通过源码可以知道block中的isa指针指向的是_NSConcreteStackBlock类对象地址。那么block是否就是_NSConcreteStackBlock类型的呢？

我们通过代码用class方法或者isa指针查看具体类型。

void (^block)(void) = ^{
    NSLog(@"Hello");
};
NSLog(@"%@", [block class]);
NSLog(@"%@", [[block class] superclass]);
NSLog(@"%@", [[[block class] superclass] superclass]);
NSLog(@"%@", [[[[block class] superclass] superclass] superclass]);
/** 输出：
__NSGlobalBlock__
__NSGlobalBlock 
NSBlock 
NSObject
*/

从上述打印内容可以看出block最终都是继承自NSBlock类型，而NSBlock继承于NSObjcet。那么block其中的isa指针其实是来自NSObject中的。这也印证了block的本质其实就是OC对象。

3.1 `block`的种类

block有3种类型

__NSGlobalBlock__ （ _NSConcreteGlobalBlock ）
__NSStackBlock__ （ _NSConcreteStackBlock ）
__NSMallocBlock__ （ _NSConcreteMallocBlock ）

通过代码查看一下block在什么情况下其类型会各不相同

// 1. 内部没有调用外部变量的block
void (^block1)(void) = ^{
    NSLog(@"Hello");
};
// 2. 内部调用外部变量的block
int a = 10;
void (^block2)(void) = ^{
      NSLog(@"Hello - %d",a);
};
// 3. 直接调用的block的class
NSLog(@"%@ %@ %@", [block1 class], [block2 class], [^{
    NSLog(@"%d",a);
} class]);
// 输出： __NSGlobalBlock__ __NSMallocBlock__ __NSStackBlock__

但是我们上面提到过，上述代码转化为cpp代码查看源码时却发现block的类型与打印出来的类型不一样，cpp源码中三个block的isa指针全部都指向_NSConcreteStackBlock类型地址。

我们可以猜测runtime运行时过程中也许对类型进行了转变。最终类型当然以runtime运行时类型也就是我们打印出的类型为准。

3.2 `block`在内存中的布局

通过下面一张图看一下不同block的存放区域

block_memory_layout

上图中可以发现，根据block的类型不同，block存放在不同的区域中。

数据段中的__NSGlobalBlock__直到程序结束才会被回收，不过我们很少使用到__NSGlobalBlock__类型的block，因为这样使用block并没有什么意义。

__NSStackBlock__类型的block存放在栈中，我们知道栈中的内存由系统自动分配和释放，作用域执行完毕之后就会被立即释放，而在相同的作用域中定义block并且调用block似乎也多此一举。

__NSMallocBlock__是在平时编码过程中最常使用到的。存放在堆中需要我们自己进行内存管理。

3.3 `block`是如何定义其类型

block是如何定义其类型，依据什么来为block定义不同的类型并分配在不同的空间呢？首先看下面一张图

block_memory_type

接着我们使用代码验证上述问题，首先关闭ARC回到MRC环境下（automatic reference counting），因为ARC会帮助我们做很多事情，可能会影响我们的观察。

// Global：没有访问auto变量：__NSGlobalBlock__
void (^block1)(void) = ^{
    NSLog(@"block1---------");
};
// Stack：访问了auto变量： __NSStackBlock__
int a = 10;
void (^block2)(void) = ^{
    NSLog(@"block2---------%d", a);
};
NSLog(@"%@ %@", [block1 class], [block2 class]);
// 输出：__NSGlobalBlock__ __NSStackBlock__
            
// __NSStackBlock__调用copy ： __NSMallocBlock__
NSLog(@"%@", [[block2 copy] class]);
// 输出：__NSMallocBlock__

通过打印的内容可以发现正如上图中所示。

没有访问auto变量的block是 __NSGlobalBlock__类型的，存放在数据段。

访问了auto变量的block是__NSStackBlock__类型的，存放在栈段。

__NSStackBlock__类型的block调用copy成为__NSMallocBlock__类型并被复制存放在堆段。

上面提到过__NSGlobalBlock__类型的我们很少使用到，因为如果不需要访问外界的变量，直接通过函数实现就可以了，不需要使用block。

但是__NSStackBlock__访问了auto变量，并且是存放在栈的，栈的代码在作用域结束之后内存就会被销毁，那么我们很有可能block内存销毁之后才去调用他，那样就会发生问题，通过下面代码可以证实这个问题。

// __NSStackBlock__类型的block，在栈区，离开作用域会自动释放
void (^block)(void);
void test()
{
    // __NSStackBlock__
    int a = 10;
    block = ^{
        NSLog(@"block---------%d", a);
    };
}

int main(int argc, char * argv[]) {
    
    NSString * appDelegateClassName;
    
    @autoreleasepool {
        // __NSStackBlock__
        test();
        block();
        // 输出：block----------504337512
    }
    
}

可以发现a的值变为了不可控的一个数字。为什么会发生这种情况呢？因为上述代码中创建的block是__NSStackBlock__类型的，因此block是存储在栈的，内存会自动释放，那么当test函数执行完毕之后，栈内存中block所占用的内存已经被系统回收，因此就有可能出现乱得数据。查看其c++代码可以更清楚的理解:

void (*block)(void);

// test方法执行完毕之后，内存被回收，结构体中的值可能会错乱
struct __test_block_impl_0 {
  struct __block_impl impl;
  struct __test_block_desc_0* Desc;
  int a;
  __test_block_impl_0(void *fp, struct __test_block_desc_0 *desc, int _a, int flags=0) : a(_a) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __test_block_func_0(struct __test_block_impl_0 *__cself) {

    // 取出的数据可能已经不是原来的数据
    int a = __cself->a; 
    // 调用block的时候，此时内存可能已经存放了其他的数据
    NSLog((NSString *)&__NSConstantStringImpl__var_folders_jp_wpw4tlhn0qn91rgns6wx4dh00000gn_T_main_1b7866_mi_0, a);
}

static struct __test_block_desc_0 {
  size_t reserved;
  size_t Block_size;
} __test_block_desc_0_DATA = { 0, sizeof(struct __test_block_impl_0)};

// test方法
void test()
{

    int a = 10;
    
    // 存储在栈内存中，test方法执行完毕之后会被销毁
    block = ((void (*)())&__test_block_impl_0((void *)__test_block_func_0, &__test_block_desc_0_DATA, a));
}

为了避免这种情况发生，可以通过copy将NSStackBlock类型的block转化为NSMallocBlock类型的block，将block存储在堆中，以下是修改后的代码。

// __NSStackBlock__ 调用copy，转移到堆区，转化为__NSMallocBlock__
int age = 10;
block = [^{
    NSLog(@"block---------%d", age);
} copy];
[block release];

// 输出：block---------10

此时在打印就会发现数据正确

那么其他类型的block调用copy会改变block类型吗？下面表格已经展示的很清晰了。

block_memory_copy

所以在平时开发过程中MRC环境下经常需要使用copy来保存block，将栈上的block拷贝到堆中，即使栈上的block被销毁，堆上的block也不会被销毁，需要我们自己调用release操作来销毁。而在ARC环境下系统会自动copy。

3.4 `ARC`帮我们做了什么

在ARC环境下，编译器会根据情况自动将栈上的block进行一次copy操作，将block复制到堆上。

那么什么情况下ARC会自动将block进行一次copy操作呢？

block作为函数返回值时;
将block赋值给__strong修饰的变量时;
block作为Cocoa API中方法名含有usingBlock的方法参数时;
block作为GCD API的方法参数时

以下代码都在ARC环境下执行。

3.4.1 `block`作为函数返回值时

// ARC环境：block作为函数返回值时，自动将block进行一次copy操作
typedef void (^Block)(void);
Block myblock()
{
    int a = 10;
    // 上文提到过，block中访问了auto变量，此时block类型应为__NSStackBlock__
    Block block = ^{
        NSLog(@"---------%d", a);
    };
    return block;
}


Block block = myblock();
block();
// 打印block类型为 __NSMallocBlock__
NSLog(@"%@",[block class]);
// 输出：
// ---------10
// __NSMallocBlock__

上文提到过，如果在block中访问了auto变量时，block的类型为__NSStackBlock__，上面打印内容发现block为__NSMallocBlock__类型的，并且可以正常打印出a的值，说明block内存并没有被销毁。

上面提到过，block进行copy操作会转化为__NSMallocBlock__类型，来将block复制到堆中，那么说明RAC在 block作为函数返回值时会自动帮助我们对block进行copy操作，以保存block，并在适当的地方进行release操作。

3.4.2 将`block`赋值给`__strong`修饰的变量时

block被强指针引用时，ARC也会自动对block进行一次copy操作。

// block内没有访问auto变量
Block block = ^{
     NSLog(@"block---------");
};
NSLog(@"%@",[block class]);
// 输出：__NSGlobalBlock__
            
int a = 10;
// block内访问了auto变量，但没有赋值给__strong指针
NSLog(@"%@",[^{
    NSLog(@"block1---------%d", a);
} class]);
// 输出：__NSStackBlock__
            
// block赋值给__strong指针
Block block2 = ^{
    NSLog(@"block2---------%d", a);
};
NSLog(@"%@",[block2 class]);
// 输出：__NSMallocBlock__

查看打印内容可以看出，当block被赋值给__strong指针时，ARC会自动进行一次copy操作。

3.4.3 `block`作为`Cocoa API`中方法名含有`usingBlock`的方法参数时

例如：遍历数组的block方法，将block作为参数的时候。

NSArray *array = @[];
[array enumerateObjectsUsingBlock:^(id  _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
            
}];

3.4.4 `block`作为`GCD API`的方法参数时

例如：GDC的一次性函数或延迟执行的函数，执行完block操作之后系统才会对block进行release操作。

static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
                        
});
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
                        
});

4. `block`声明的写法

通过上面对MRC及ARC环境下block的不同类型的分析，总结出不同环境下block属性建议写法。

MRC下block属性的建议写法:

@property (copy, nonatomic) void (^block)(void);

ARC下block属性的建议写法:

@property (strong, nonatomic) void (^block)(void);
@property (copy, nonatomic) void (^block)(void);

block的本质1

问题

1. block的底层结构

1.1 底层block的声明

参数1：(void *)__main_block_func_0

参数2：&__main_block_desc_0_DATA

参数3：age

总结__main_block_impl_0结构体

验证block的本质确实是__main_block_impl_0结构体类型。

1.2 底层调用block

1.3 总结

2. block捕获变量的原理

2.1 局部变量

auto变量

static变量

2.2 全局变量

2.3 疑问：以下代码中block是否会捕获变量呢？

3. block的类型

3.1 block的种类

3.2 block在内存中的布局

3.3 block是如何定义其类型

3.4 ARC帮我们做了什么

3.4.1 block作为函数返回值时

3.4.2 将block赋值给__strong修饰的变量时

3.4.3 block作为Cocoa API中方法名含有usingBlock的方法参数时

3.4.4 block作为GCD API的方法参数时

4. block声明的写法

你可能感兴趣的:(block的本质1)