iOS-Block本质

Block本质上是一个OC对象，从底层结构就可以看的出来内部也有一个isa指针。
Block封装了函数调用，以及函数调用环境(参数，访问外面的值)的OC对象。

可以写一个简单的block，通过clang编译器生成对应的.cpp文件来看到对应的block底层。
终端切到block代码对应文件的目录下，敲如下：

xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc block所在的文件名.m

1. Block底层结构

int a = 10;
void (^myblock)(void) = ^{
    NSLog(@"myblock is %d",a);
};
myblock();

通过以上代码，生成对应的.cpp,可以看到，Block底层的结构。__block_impl这是个结构体，就相当于block的第一个成员就是isa指针。也可以看出，block把外部变量包装到了内部。

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;  //=> __main_block_desc_0
  int a;   // 外面定义的变量
  
  // C++构造函数
  // a(_a) 将 a = _a; _a=10
 __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;
  }
};

_block_impl 结构

struct __block_impl {
  void *isa;
  int Flags;
  int Reserved;
  void *FuncPtr;  //指向block函数实现的指针
};

__main_block_desc_0 结构

用来描述block

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;  // block结构体大小
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};

block函数实现 __main_block_func_0()

这个函数的地址就是block内部的FuncPtr

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
int a = __cself->a; // bound by copy
NSLog((NSString *)&__NSConstantStringImpl__var_folders_6y_1qw3s7mx3dj1m3w2r4spjzp40000gn_T_main_9ad076_mi_1,a);
}

block调用

int main(int argc, const char * argv[]) {
 int a = 10;
 
// 定义block变量 
// 参数1:__main_block_func_0 
// 参数2：__main_block_desc_0_DATA
// 参数3：a变量
void (*myblock)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, a));

// 执行block内部代码
// block->FuncPtr()
((void (*)(__block_impl *))((__block_impl *)myblock)->FuncPtr)((__block_impl *)myblock);

 return 0;
}

2. Block捕获

block捕获：block内部会专门新增一个成员来存储外部变量。

当block访问局部变量，block就会捕获

访问auto变量原来是什么类型，捕捉的就是什么类型，如果捕捉的是基本数据类型，那就是值引用，直接存储的变量的值。如果捕捉的是对象类型，那么就是对象的地址。
访问static变量->指针传递，存储的是局部变量的地址值。

auto自动变量，随时都可能会销毁，而static变量会一直在内存中，所以可以存储地址。全局变量一直在内存中，且谁都可以用，所以block不用捕获。

3. Block类型

从上面block的结构可以看出有这样一行代码。block是什么类型，是什么对象就取决于block的isa指针指向。不管block是什么类型，都是NSBlock类型。isa指针本质是来自于NSObject，因为block是个OC对象。

// _NSConcreteStackBlock -> NSStackBlock
impl.isa = &_NSConcreteStackBlock;

NSGlobalBlock
没有访问auto变量，且调用copy方法也不会做什么操作，依然还是NSGlobalBlock类型。
NSStackBlock
访问了auto变量,内存放在栈上。一旦离开了作用域，block就可能被销毁。这样在外面访问的时候就可能会出现问题。
NSMallocBlock
最常用。NSStackBlock调用copy方法就会变成NSMallocBlock。如果堆上的block进行copy操作的话，引用计数器会增加。

在开发中，经常要对block进行copy操作，希望保住block的命。这也是为什么block作为属性时修饰词要用copy。ARC会根据情况👇自动把栈上的Block拷贝copy到堆上变成NSMallocBlock类型。

gcd里面的block
当有强指针指向Block时
Foundation框架中含有usingBlock字眼的block
将block作为返回值时

4. Block内存管理

循环引用: 互相强引用导致无法释放。

不管是MRC还是ARC，栈上的Block是不会拥有外面的对象。即不管捕获的对象是强指针指向还是弱指针指向，都无法保住它的命。堆上的Block可以。

ARC中
堆上的Block内部会根据捕获对象此时指向的指针类型(强指针，还是弱指针__weak修饰)来定义内部的对象类型(是强指针还是弱指针指向)。如果捕获的对象是指针指向的话，__main_block_desc_0 会新增两个方法copy()和dispose()。这也是为什么__weak能够解决循环引用。

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  
  // 这个是weak还是strong是根据外面传进来的是weak还是strong
  NSObject *__weak weakObj;
  
  ...
};

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};

__main_block_func_0

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
NSObject *__weak weakObj = __cself->weakObj; // bound by copy

        NSLog((NSString *)&__NSConstantStringImpl__var_folders_6y_1qw3s7mx3dj1m3w2r4spjzp40000gn_T_main_bbffa5_mi_1,weakObj);
    }
    
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->weakObj, (void*)src->weakObj, 3/*BLOCK_FIELD_IS_OBJECT*/);}
static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->weakObj, 3/*BLOCK_FIELD_IS_OBJECT*/);}

__block

__block 修饰，block内部就可以修改auto变量。
__block 可以解决循环引用。ARC和MRC。

__block不会修改变量的性质，也就是自动变量还是自动变量。__block不能修饰static变量，也不能修饰全局变量，只能修饰auto变量。一旦用__block修饰的变量，编译器会把这个变量包装成一个对象。

前提是在堆上的Block:
ARC中block内部会对这个对象进行强引用。__block也能解决ARC环境中的循环引用问题，但是一定要调用block，并且在block内部要将对象置为nil。这样看来也是不安全的，因为不确定block是否会被执行，什么时候执行。

MRC中，__block修饰的变量，block内部是不会对其进行强引用的，所以在MRC中__block也可以用来解决循环引用。

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  
  // 把基本数据a包装成一个对象a，并且不管外面传的是weak还是strong
  // 只要用__block修饰，block内部就会对这个对象进行强引用
  // 前提是堆上的block
    __Block_byref_a_0 *a; 
    
  ...
};

__Block_byref_a_0

__forwarding这个指针指向的是block本身那为什么还需要这个指针呢？因为block被拷贝到堆上的时候，会让栈上__block结构体中__forwarding指针指向堆上的block，保证数据正确。

struct __Block_byref_a_0 {
  void *__isa;

  // __forwarding指向block本身
__Block_byref_a_0 *__forwarding;

 int __flags;
 int __size;
 
 // 这里的变量类型也是根据传入进的类型而定
 // 如果传入的是对象类型，
 // 那么这里也是根据传入的对象的指针强弱定义这里变量的强弱指向
 // 从这个角度也可以看__weak可以解决循环引用的问题
 int a; 
 
 // 如果传入的是对象这里也会多两个方法copy()和dispose()
 // 要对传入对象进行内存管理
 ...
 
};

weak & unsafe_unretained

都可以解决循环引用的问题。区别就在于当对象销毁时的处理方式不一样。__unsafe_unretained是不安全的。在MRC中__weak这个关键字用不了。