OC Block底层原理

1. block的原理是怎样的？本质是什么？
   答: block本质是封装了函数调用和调用环境的OC对象,本质是结构体，block结构体内部有需要执行的代码块funcPtr和自己的大小size.

2. __block的作用是什么？有什么使用注意点？
   答:__block 修饰的变量可以在block 内部修改. 注意循环引用

3. block的属性修饰词为什么是copy？使用block有哪些使用注意?
   答: 如果block在栈空间上，那么block可能会被释放，使用copy是为了把block copy到堆上。注意循环引用的问题.

4. block在修改NSMutableArray，需不需要添加__block？
   答: 如果是调用NSMutablearray的addObject方法，则不需要添加__block，如果直接修改NSMutablearray则需要。

int main(int argc, const char * argv[]) {
    int age = 10;
    void(^block)(int, int) = ^(int a, int b) {
        printf("this is block,a = %d,b = %d\n",a,b);
        printf("this is block,age = %d\n",age);
    };
    block(3, 5);
    return 0;
}
// 打印:
// this is block,a = 3,b = 5
// this is block,age = 10

问题: 为什么我们在定义block之后修改局部变量age的值,在block调用的时候无法生效?
答: 1.因为在定义block的时候,就把age值存在了__main_block_impl_0的结构体中.

2. 当调用block的时候,就直接将age 从block中取出来.
3. 因此在block定义以后,对局部变量进行修改无法被block捕获.

定义block变量

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

__mian_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对象占用内存大小
  }
};

struct __main_block_impl_0 内部有一个同名构造函数, __main_block_impl_0(), 构造函数中对一些变量进行赋值最终返回一个结构体.
那么也就是说最终将一个__main_block_impl_0的结构体的地址赋值给了变量block.

(void*)__main_block_func_0

__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()的构造函数中,并保存在结构体中.

__main_block_desc_0 结构体定义

static struct __main_block_desc_0 {
size_t reserved;
size_t Block_size; // 存储着__main_block_impl_0的占用空间大小

} _main_block_desc_0_DATA = {0, sizeof(struct __main_block_impl_0)};

size_t Block_size, 存储着__main_block_impl_0 的占用空间大小
最终将__main_block_desc_0 的结构体地址传入到, __mian_block_func_0中赋值给Desc.

__block_impl 结构体定义

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

__block_impl 的内部有一个isa指针, 说明block的本质就是一个struct, 而构造函数中__main_block_impl_0()将传入的值存储在了 __main_block_impl_0结构体中,最终将结构体的值赋值给block.

总结:

1. __block_impl的结构体中isa 指针存储着&_NSConcreteStackBlock地址.
2. block代码块的代码被封装成 __main_block_func_0函数,
   FuncPrt则储存着__mian_block_func_0函数的地址.
3. Desc指向 __main_block_desc_0结构体对象,其中存储__main_block_impl_0所占用的内存.

所以结构体之间的关系:

block的内部调用

block变量的捕获

auto变量

auto只存在于局部变量中,属于值传递.

static变量

static 修饰的变量为指针传递(引用),同样会被block 捕获;

void add() {
    auto int c = 30; // 传入值
    static int d = 40; // 传入地址
    void(^block)(void) = ^ {
        printf("c = %d, d = %d\n", c, d);
    };
    c = 5;
    d = 6;
    block();
}

差异性:

1. 自动变量有可能被销毁,那如果去访问被销毁的地址会发生坏内存的情况,所以自动变量一定要值传递的.
2. static静态变量不会被销毁,所以可以传递地址,因而传递的是值的地址, 所以在block调用之前修改了地址中的值,所以值会改变.

全局变量

int a = 10;
static int b = 11;
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        void(^block)(void) = ^{
            NSLog(@"hello, a = %d, b = %d", a,b);
        };
        a = 1;
        b = 2;
        block();
    }
    return 0;
}
// log hello, a = 1, b = 2

发现__main_block_impl_0 并没有添加任何变量, 因此block 不需要捕获全局变量.

总结: 局部变量都会被block捕获,自动变量是值类型捕获,静态变量为地址捕获,全局变量则不会被捕获.

修改block 内部值的优先级:
auto > static > 全局变量

block类型

上面了解到 block的isa 指针指向 _NSConCreteStrackBlock类对象地址.
向上继承关系:

__NSGlobalBlock__  ->  __NSGlobalBlock  -> NSBlock -   >NSObject

block 的继承关系

block 的三种类型

__NSGlobalBlock__ ( _NSConCreteGlobalBlock)
__NSStackBlock ( _NSConCreteStackBlock)
__NSMallocBlock ( _NSConcreteMallocBlock)

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // 无访问auto变量, 类型为: __NSGlobalBlock__,数据段存放
        void(^block1)(void) = ^{
             NSLog(@"block 1");
        };
        // 访问了auto, 类型为__NSStackBlock__,存放在栈中
        int a = 10;
        void(^block2)(void) = ^{
            NSLog(@"block2 = %d", a);
        };
        
        NSLog(@"block1类型:%@\n, block2类型:%@\n, block3:%@\n",
              [block1 class],
              [block2 class],
// __NSStackBlock__类型block调用copy 成为__NSMallocBlock__
// 并复制在堆中
              [^{ NSLog(@"%d", a);
            
        } class]);
  
    }
    return 0;
}
// 打印值:
 block1类型:__NSGlobalBlock__
block2类型:__NSMallocBlock__
block3:__NSStackBlock__

block在内存中的存储

block在内存中的分配

上图中可以发现，根据block的类型不同，block存放在不同的区域中。
数据段中的NSGlobalBlock直到程序结束才会被回收，不过我们很少使用到NSGlobalBlock类型的block，因为这样使用block并没有什么意义。
NSStackBlock类型的block存放在栈中，我们知道栈中的内存由系统自动分配和释放，作用域执行完毕之后就会被立即释放，而在相同的作用域中定义block并且调用block似乎也多此一举。
NSMallocBlock是在平时编码过程中最常使用到的。存放在堆中需要我们自己进行内存管理。

block是如何定义其类型

block分配空间

// 注意: 栈中的代码在作用域结束之后内存就会被销毁

void (^block)(void);
void test() {
    // __NSStackBlock__,栈中
    int a = 10;
    block = ^{
        NSLog(@"block---------%d", a);
    };
}
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        test();
        block();
    }
    return 0;
}
// 因此可能会出现乱数据.

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

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

其他类型的block调用copy改变block类型情况

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

所以在ARC 上:

1. block作为函数返回值时:

typedef void (^Block)(void);
Block myblock() {
    int a = 10;
    // 上文提到过，block中访问了auto变量，此时block类型应为__NSStackBlock__
    Block block = ^{
        NSLog(@"---------%d", a);
    };
    return block;
}
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Block block = myblock();
        block();
       // 打印block类型为 __NSMallocBlock__
        NSLog(@"%@",[block class]);
    }
    return 0;
}

2. 将block赋值给__strong指针时:

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // 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(@"%@",[block1 class]);// __NSMallocBloak__
    }
    return 0;

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

例如：遍历数组的block方法，将block作为参数的时候。
NSArray *array = @[];
[array enumerateObjectsUsingBlock:^(id _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {

}];

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(), ^{

});

声明写法

通过上面对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);