OC语法 Block

问题：

1. Block的原理、本质是什么？
2. Block的分类？
3. Block的捕获机制？
4. Blcok内部的内存管理？
5. __Block的作用？用什么注意点？
6. Block的属性修饰词为什么是Copy？使用Block有什么注意点？
7. 循环引用问题

Block的本质

Block本质是封装了函数和函数调用的OC对象。
Block底层实现：

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

成员变量: impl 类型为__block_impl

struct __block_impl {
  void *isa;   //和OC对象一样有个isa指针
  int Flags;  // 当block被copy时，应该执行的操作
  int Reserved; // 保留字段
  void *FuncPtr; // 方法指针
};

成员变量: Desc

static struct __main_block_desc_0 {
  size_t reserved; // 保留字段
  size_t Block_size; // block 的大小
}

Block的分类

• NSGlobalBlock 保存子数据段
• NSStackBlock 保存子栈
• NSMallocBlock 保存子堆，NSStackBlockcopy后得到，blcok引用计数加一。
  • MRC NSStackBlockcopy后得到。
  • ARC 系统会根据情况自动调用copy
    • blcok 被强引用。
    • GCD内部的block调用。
    • blcok 在方法中作为参数时。
    • blcok 在方法中作为返回值时。

Block的捕获机制

Block的捕获机制，是因为block是封装的一个函数，在一个函数内部，调用另一个函数内部的变量，超出了变量的作用域，所以需要将变量捕获到blcok内部。

• 全局变量 ：不捕获、全局都可以调用。
  OC代码：

void(^block)(void);
int a = 10;
#import 
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        block = ^{
            NSLog(@"a = %d",a);
        };
         block();
    }
    return 0;
}

clang编译后的C++文件：

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {

            NSLog((NSString *)&__NSConstantStringImpl__var_folders_1z_bw1zh_rj5rg3glg1bxmzmnzc0000gp_T_main_1366d6_mi_0,a);
        }

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)};
int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
        block = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
         ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
    }
    return 0;
}

可以看到block并没有捕获全局变量a,因为block内部可以随时访问全局变量a。

• 局部变量 ： 捕获、但是访问值的方式不同。
  • 局部静态变量： static 修饰的局部变量，内存保存在数据段，作用域为整个app，在另一个函数内可以通过变量地址访问，使用变量，访问值的方式为引用传递。

OC代码：

void(^block)(void);
#import 
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        static int a = 10;
        block = ^{
            NSLog(@"a = %d",a);
        };
         block();
    }
    return 0;
}

clang编译后的C++代码：

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int *a;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, 
  int *_a, int flags=0) : a(_a) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  int *a = __cself->a; // bound by copy

  NSLog((NSString *)&__NSConstantStringImpl__var_folders_1z_bw1zh_rj5rg3glg1bxmzmnzc0000gp_T_main_ca9917_mi_0,(*a));
}

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)};
int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 

        static int a = 10;
        block = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, &a));
         ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
    }
    return 0;
}

可以看出__main_block_impl_0 同样多出了个成员变量a，但是此时成员变量a的类型为指针类型，也可以看出__main_block_func_0()函数在构造结构体__main_block_func_0时传入的参数是&a ,
所以blcok同样捕获了局部静态变量a的值，并保存到__main_block_impl_0的成员变量a上，只是成员变量a的类型为指针,这是因为static 修饰后的局部变量a虽然作用域不变,但生存期和全局变量相同，为整个程序，一旦超出局部变量a的作用域，尽管局部变量a的地址还存在，但不能提供变量名a去访问。。为防止，block内部访问局部变量a时，block不在局部变量a的作用域，所以block内部捕获局部变量a的地址，通过地址去访问局部变量a。

• 局部自动变量：auto(默认省略) 修饰的局部变量。内存保存在栈，作用域为函数内部，超出作用域自动销毁，无法通过变量地址访问，使用变量，需要将变量的值传递进另一个函数，访问值的方式为值传递。

基本数据类型
OC代码如下：

void(^block)(void);
#import 
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        int a = 10;
        block = ^{
            NSLog(@"a = %d",a);
        };
         block();
    }
    return 0;
}

clang编译后的C++代码：

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int a;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _a, int flags=0) : a(_a) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  int a = __cself->a; // bound by copy

            NSLog((NSString *)&__NSConstantStringImpl__var_folders_1z_bw1zh_rj5rg3glg1bxmzmnzc0000gp_T_main_8b3967_mi_0,a);
        }

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)};
int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 

        int a = 10;
        block = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, a));
         ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
    }
    return 0;
}

可以看出__main_block_impl_0结构体内多了个成员变量int a,且在构造函数__main_block_impl_0 ()构造结构体__main_block_impl_0是传了个参数 int _a,且 : a(_a) ，_a的值赋给了成员变量a，在看函数__main_block_impl_0 ()函数在构造结构体__main_block_func_0时可以发现
参数_a的值为局部变量a，所以block捕获了局部变量a的值并保存到__main_block_impl_0的成员变量a上。

对象数据类型的捕获机制

OC代码:

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Person *p = [[Person alloc] init];
        void(^block)(void) = ^{
            NSLog(@"p = %@",p);
        };
        block();
        NSLog(@"-----");
    }
    return 0;
}

clang编译后的C++代码:

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  Person *p;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, Person *_p, int flags=0) : p(_p) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  Person *p = __cself->p; // bound by copy

  NSLog((NSString *)&__NSConstantStringImpl__var_folders_1z_bw1zh_rj5rg3glg1bxmzmnzc0000gp_T_main_277de0_mi_0,p);
}
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src{
  _Block_object_assign((void*)&dst->p, (void*)src->p, 3/*BLOCK_FIELD_IS_OBJECT*/);
}

static void __main_block_dispose_0(struct __main_block_impl_0*src){
  _Block_object_dispose((void*)src->p, 3/*BLOCK_FIELD_IS_OBJECT*/);
}

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
  void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*);
  void (*dispose)(struct __main_block_impl_0*);
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0), __main_block_copy_0, __main_block_dispose_0};
int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
        Person *p = ((Person *(*)(id, SEL))(void *)objc_msgSend)((id)((Person *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("Person"), sel_registerName("alloc")), sel_registerName("init"));
        void(*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, p, 570425344));
        ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
        NSLog((NSString *)&__NSConstantStringImpl__var_folders_1z_bw1zh_rj5rg3glg1bxmzmnzc0000gp_T_main_277de0_mi_1);
    }
    return 0;
}

可以看出此时的__main_block_impl_0结构体内有成员变量Person *p，局部变量 p的值赋值给了成员变量p。

注意：Block捕获的变量，基本数据类型：会随blcok的销毁，变量一同销毁。如果是OC对象类型，内存是如何管理的？

Block内部的内存管理

• 基本数据类型：会随blcok的销毁，变量一同销毁。
• 对象类型：
  • blcok 底层struct __main_block_desc_0* Desc;结构体内生成
    void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*)和
    void (*dispose)(struct __main_block_impl_0*)方法
  • 在Block调用copy时调用void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*)
    • void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*)内部调用
      _Block_object_assign((void*)&dst->p, (void*)src->p, 3/*BLOCK_FIELD_IS_OBJECT*/)根据捕获的变量的指针修饰类型是否为强引用对其进行内存管理。
  • 在blcok销毁时调用void (*dispose)(struct __main_block_impl_0*)
    • void (*dispose)(struct __main_block_impl_0*)内部调用
      _Block_object_dispose((void*)src->p, 3/*BLOCK_FIELD_IS_OBJECT*/)释放捕获的变量。

__block的作用

blcok捕获的变量

• 局部静态变量： static 修饰的局部变量，内存保存在数据段，作用域为整个app，可以随便修改。
• 局部自动变量：auto(默认省略) 修饰的局部变量。内存保存在栈，作用域为函数内部，超出作用域自动销毁，不能访问，也不能修改。

那么如何修改局部自动变量呢？
__block 就是为了实现这一功能。
__block会将修饰的变量封装成OC对象，对象内部保存和变量的变量名、类型一样的变量，这样block捕获的就是封装后的OC对象的值，OC的值不能变，但是OC对象的变量，可以修改，我们在block外部和内部实际访问的事OC对象内的和和变量的变量名、类型一样的变量。

image.png

image.png

__blcok底层实现

image.png

image.png

__forwarding 指针为什么会如此改变？
当blcok 从栈上拷贝到堆上后，__block变量也被拷贝到堆上。

image.png

但是我们要保证，blcok内部修改后的变量，block外部访问的变量值也一样，block
此时是在堆上， __forwarding 指针指向自身（堆上的变量），blcok外部的变量在栈上指向堆上的变量，保证了变量一致。

__block修饰的变量封装的OC对象内部保存的变量的内存管理同block捕获的变量的内存管理一样，__block修饰的变量封装的OC对象内部也有copy、dispose方法。

Block的属性修饰词为什么是Copy？使用Block有什么注意点？

主要是在MRC下，blcok默认捕获变量后是在栈上，使用copy修饰后进行强引用拷贝到堆上，
ARC下使用strong也是一样的，但是延续了MRC下的习惯，和提醒block是copy到堆上的，也就普遍使用copy修饰。

注意点：循环引用问题

Block的循环引用问题

解决循环引用。

• __weak 对象释放时block内部，对象会设置为nil。
  

  

  image.png

• __unsafe_unretained unretained不会进行retain操作，但是指针存储的地址不变，会产生野指针。
  

  

  image.png