Block

结构

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

int f1 = 55;
int f2 = 55;

struct __Block_byref_a1_0 {
  void *__isa;
__Block_byref_a1_0 *__forwarding;
 int __flags;
 int __size;
 int a1;
};

struct __Animal__init_block_impl_0 {
  struct __block_impl impl;
  struct __Animal__init_block_desc_0* Desc;
  int a2;
  Animal *self;
  int *c1;
  int *c2;
  __Block_byref_a1_0 *a1; // by ref
  __Animal__init_block_impl_0(void *fp, struct __Animal__init_block_desc_0 *desc, int _a2, Animal *_self, int *_c1, int *_c2, __Block_byref_a1_0 *_a1, int flags=0) : a2(_a2), self(_self), c1(_c1), c2(_c2), a1(_a1->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static int __Animal__init_block_func_0(struct __Animal__init_block_impl_0 *__cself, int te1, int te2) {
  __Block_byref_a1_0 *a1 = __cself->a1; // bound by ref
  int a2 = __cself->a2; // bound by copy
  Animal *self = __cself->self; // bound by copy
  int *c1 = __cself->c1; // bound by copy
  int *c2 = __cself->c2; // bound by copy

            (a1->__forwarding->a1) = a2;
            ((void (*)(id, SEL, int))(void *)objc_msgSend)((id)self, sel_registerName("setB1:"), ((int (*)(id, SEL))(void *)objc_msgSend)((id)self, sel_registerName("b2")));
            (*c1) = (*c2);
            f1 = f2;
            return te1 + te2;
        }
static void __Animal__init_block_copy_0(struct __Animal__init_block_impl_0*dst, struct __Animal__init_block_impl_0*src) {_Block_object_assign((void*)&dst->a1, (void*)src->a1, 8/*BLOCK_FIELD_IS_BYREF*/);_Block_object_assign((void*)&dst->self, (void*)src->self, 3/*BLOCK_FIELD_IS_OBJECT*/);}

static void __Animal__init_block_dispose_0(struct __Animal__init_block_impl_0*src) {_Block_object_dispose((void*)src->a1, 8/*BLOCK_FIELD_IS_BYREF*/);_Block_object_dispose((void*)src->self, 3/*BLOCK_FIELD_IS_OBJECT*/);}

static struct __Animal__init_block_desc_0 {
  size_t reserved;
  size_t Block_size;
  void (*copy)(struct __Animal__init_block_impl_0*, struct __Animal__init_block_impl_0*);
  void (*dispose)(struct __Animal__init_block_impl_0*);
} __Animal__init_block_desc_0_DATA = { 0, sizeof(struct __Animal__init_block_impl_0), __Animal__init_block_copy_0, __Animal__init_block_dispose_0};

static instancetype _I_Animal_init(Animal * self, SEL _cmd) {
    self = ((Animal *(*)(__rw_objc_super *, SEL))(void *)objc_msgSendSuper)((__rw_objc_super){(id)self, (id)class_getSuperclass(objc_getClass("Animal"))}, sel_registerName("init"));
    if (self) {

        __attribute__((__blocks__(byref))) __Block_byref_a1_0 a1 = {(void*)0,(__Block_byref_a1_0 *)&a1, 0, sizeof(__Block_byref_a1_0)};
;
        int a2 = 0;
        static int c1 = 0;
        static int c2 = 0;
        int e1 = 10;

        int (*block)(int, int) = ((int (*)(int, int))&__Animal__init_block_impl_0((void *)__Animal__init_block_func_0, &__Animal__init_block_desc_0_DATA, a2, self, &c1, &c2, (__Block_byref_a1_0 *)&a1, 570425344));

        int g = ((int (*)(__block_impl *, int, int))((__block_impl *)block)->FuncPtr)((__block_impl *)block, e1, 20);
        NSLog((NSString *)&__NSConstantStringImpl__var_folders_4m_xm_v2tn54_z1csnt42kykgmm0000gn_T_Animal_0d46d1_mi_0, g);
    }
    return self;
}



- (instancetype)init
{
    self = [super init];
    if (self) {
        
        __block int a1;
        int a2 = 0;
        static int c1 = 0;
        static int c2 = 0;
        int e1 = 10;
    
        int (^block)(int, int) = ^(int te1, int te2){
            a1 = a2;
            self.b1 = self.b2;
            c1 = c2;
            f1 = f2;
            return te1 + te2;
        };
        
        int g = block(e1, 20);
        NSLog(@"%d", g);
    }
    return self;
}

结论:

1. 局部变量 a1, a2, 因为 a1用__block修饰, 所以捕获a1的地址, a2只是访问变量, 所以直接捕获a2的值.
   2.局部变量 self, 因为b1和b2都是self的属性, 所以直接捕获了self.
2. 静态变量c1和c2是static修饰的, 捕获了地址.
3. 全局f1和f2, 没有捕获, 内部直接访问的.

分类

• _NSConcreteGlobalBlock ：全局Block。
  1. 内部没有使用auto类型变量的block, 就是NSGlobalBlock类型
  2. copy后仍然是全局block;
  3. NSGlobalBlock类型的block, 不管怎样类型都不会改变, 依然在数据区
• _NSConcreteMallocBlock：堆Block。
  1. 堆block会捕获外部变量，存储于内存的堆区。
  2. copy后引用计数 +1
• _NSConcreteStackBlock：栈Block
  在ARC下, 一个NSStackBlock类型的block被一个__strong类型的指针引用时, 系统会将block自动复制到堆区, 变成堆block, 此时如果block内部访问的不是被__weak修饰的变量, 会引用计数 + 1, 需要等到block超出作用域, 才会引用数 - 1
  1. 内部使用了auto类型变量的block, 就是NSStackBlock类型
  2. copy后生成堆block
     1. NSStackBlock类型的block做为函数返回值时, 会将返回的block复制到堆区
     2. 将NSStackBlock类型的block赋值给__strong指针时, 会将block复制到堆区
     3. block作为Cocoa API中方法名含有usingBlock的方法参数时, block在堆区
     4. block作为GCD API的方法参数时, block在堆区

调用 _Block_copy将 block 拷贝到堆上.

• _Block_copy时候, 如果block需要释放，则直接释放
• 如果block是globalBlock不需要copy, 直接返回.
• 通过malloc申请内存空间用于接收block, 通过 memmove 将block拷贝至新申请的内存中.

通过_Block_object_assign将Block 捕获的外界变量拷贝到堆中.

• 如果是普通对象，交给系统arc处理，拷贝对象指针，引用技术+1，外界变量不能释放。
• 如果是block类型的变量，通过_Block_copy操作，将block从栈区拷贝到堆区
• 如果是__block修饰的变量，调用_Block_byref_copy函数，进行内存拷贝以及常规处理。

通过 _Block_byref_copy 将 __block 修饰的变量拷贝到堆中

• 将传入的对象，强转为Block_byref结构体类型对象。保存
• 如果没有将变量拷贝到堆上，就申请内存进行拷贝
• 如果已经拷贝，则进行处理并返回