一.block底层源码实现

1.定义一个简单的block

        int a = 100;
        void (^block)(void) = ^(){
            NSLog(@"print block");
            NSLog(@"print args %d",a);
        };

2.生成对应的底层代码:

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

3.摘取主要的代码

struct __block_impl {
    void *isa;
    int Flags;
    int Reserved;
    void *FuncPtr;
};
struct __main_block_desc_0 {
    size_t reserved;
    size_t Block_size;
};
struct __main_block_impl_0 {
    struct __block_impl impl;
    struct __main_block_desc_0* Desc;
    int a;
    // C++ 的构造函数
    __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;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself){
 int a = __cself->a; 
 NSLog((NSString *)&__NSConstantStringImpl__var_folders_qx_8kn3tsws6hz4j8n03t14prmh0000gn_T_main_8dfc00_mi_0);
 NSLog((NSString *)&__NSConstantStringImpl__var_folders_qx_8kn3tsws6hz4j8n03t14prmh0000gn_T_main_8dfc00_mi_1,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 a = 100; 
//定义block变量
void (*block)(void) = &__main_block_impl_0(
__main_block_func_0, 
&__main_block_desc_0_DATA, 
a);
// block 的调用
block->FuncPtr(block);

从以上底层代码中我们可以发现，当我们声明一个block 对应的会转换为底层c++的 __main_block_impl_0 结构体，这个结构体传入对应的参数

• __main_block_func_0(待执行函数）
• __main_block_desc_0_DATA 结构体参数
• a 外部使用的参数

得出结论:

• block 本质上也是一个oc 对象，它内部也有isa 指针
• block是封装了 函数调用以及函数的调用的 oc 对象

这样的话，我们就可以通过 void (*block)(void) 来接收这个结构体的地址，通过调用这个 FuncPtr 来调用函数。

关系图

二.block 的变量捕获

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

变量类型	捕获到block内部	访问方式
局部变量auto	✔️	值访问
局部变量static	✔️	指针传递
全局变量	❌	直接访问

auto 离开作用域就会销毁

全局变量不会被捕获，局部变量会被捕获，self 属于局部变量

三.block类型

block 有三种类型，可以通过调用class方法或者isa指针查看具体类型,最终都继承自NSBlock

block类型	环境
NSGlobalBlock	没有访问auto变量
NSStackBlock	访问auto变量
NSMallocBlock	NSStackBlock 调用了copy

// 没有访问auto变量
// 访问static 和 全局变量 都是  __NSGlobalBlock__类型
void (^block)(void) = ^(){
            NSLog(@"print block");
        };

注意ARC 环境问题

• 在ARC环境下，编译器会根据情况自动将栈上的block复制到堆上,包括以下几种情况:

  • block 作为函数返回值时
  • 将block赋值给__strong 指针时
  • block 作为 Cocoa API 中方法名含有usingBlock的方法参数时
  • block 作为GCD API 的方法参数时

• 每一种类型的block 调用copy后的结果

Block的类	副本源的配置存储域	复制效果
_NSConcreteStackBlock	栈	从栈复制到堆
_NSConcreteGlobalBlock	程序的数据区域	什么也不做
_NSConcreteMallocBlock	堆	引用计数增加

四、对象类型的auto变量

1.当block内部访问了对象类型的auto变量时

• 如果block是在栈上，将不会对auto变量产生强引用

2.如果block被拷贝到堆上

• ✔️会调用block 内部的copy 函数
• ✔️copy 函数内部会调用_Block_object_assign 函数
• ✔️_Block_object_assign函数会根据auto 变量的修饰符（__strong __weak __unsafe_unretained）操作，类似retain （形成强引用、弱引用）(注意：这里仅限于ARC时会retain，MRC时不会retain)

如果block从堆上移除

• ✔️会调用block内部的dispose函数
• ✔️dispose函数内部会调用 _Block_object_dispose 函数
• ✔️ _Block_object_dispose 函数会自动释放引用的auto 变量。类似于release

函数	调用时机
copy函数	栈上的Block复制到堆时
dispose函数	堆上的Block被废弃时

使用clang 转换OC为C++代码时，遇到

__weak问题
cannot create __weak reference in file using manual reference

解决方案:支持ARC 指定运行时系统版本

Xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc -fobjc-arc -fobjc-runtime=ios-8.0.0 main.m

五、 __block修饰符到底干了什么

1. __block 修饰符

• __block可以用于可以用于解决block内部无法修改auto变量的问题
• __block不能够修饰全局变量，静态变量（static）
• 编译器会将__block对象包装成一个对象

2. 探究__block 底层干了什么

修饰基本数据类型

   __block int a = 8;
        void (^block)(void) = ^{
            a = 10;
            NSLog(@"------");
        };
        
        block();
        NSLog(@"-----%d",a);

首先经过__block 修饰的 int a 会被转换为一个结构体__Block_byref_a_0 a，并将给这个结构体赋值

struct __Block_byref_a_0 {
  void *__isa;
__Block_byref_a_0 *__forwarding;
 int __flags;
 int __size;
 int a;
};

__Block_byref_a_0 a = {
                         0,
                         &a,
                         0,
                         sizeof(__Block_byref_a_0),
                        8};

接下下来在void (^block)(void) 中给 a 赋值,通过 a->__forwarding->a,即:

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  __Block_byref_a_0 *a = __cself->a;
   (a->__forwarding->a) = 10;
}

结论:

• __block 修饰的变量，底层会被转化成一个结构体，通过访问结构体中__forwarding (指向自身的一个指针) ，再将值赋值给结构体变量。
• 与未修饰的变量的区别是:未修饰的auto变量会被捕获到结构体内部，直接赋值

修饰对象类型

六、block 的内存管理

对象类型的auto变量、__block变量

• 当block 在栈上时，并不会对__block变量产生强引用

• 当block被copy到堆时

  • ✔️会调用block内部的copy函数
  • ✔️copy函数内部会调用__Block_object_assign函数
  • ✔️__Block_object_assign函数会对__block变量形成强引用（retain）(注意：这里仅限于ARC时会retain，MRC时不会retain)

• block 从堆中移除都会通过 dispose函数来释放

MRC环境下的内存管理情况

1.__block 修饰时

__block Person *person =  [ [Person alloc] init];

void (^block)(void) = [^{
    NSLog(@"%p",person);
} copy];

[person release];

block();

[block release];

• 结果: 当调用block() 时，person对象已经释放，block 内部并不会对person产生强引用！！！
• 分析：
  在 MRC 下首先需要主动将栈的block 拷贝到堆上（否则在执行完之后会被释放），当block 内部访问完person 对象后，手动进行了一次release操作，block内部并没有进行管理，在ARC下会主动管理这个person对象的内存

2.未进行__block 修饰时

Person *person =  [ [Person alloc] init];

void (^block)(void) = [^{
    NSLog(@"%p",person);
} copy];

[person release];

block();

[block release];

• 结果: 当调用block() 时，person对象并未释放，block 直接引用了person对象
• 分析：
  block对person对象引用，会导致person引用计数 + 1 ，当调用block的release时候，person引用计数减为 0，person才会释放

七、__block 的 __forwarding指针

__forwarding

__forwarding 指针保证了可以更改__block 修饰的变量，不论这个block是在栈上，还是在堆上。

八、解决循环引用方式

• __weak
• __unsafe_unretained
• __block

MRC 情况下 __block 不会对外部的变量产生强引用

九、总结

• block的原理是怎样的？本质是什么？
  • block是封装了函数的调用及函数调用环境的oc对象
  • block本质上也是一个oc对象，它的内部也有一个isa指针
  • 底层结构是一个结构体

ARC 下 修饰block 使用 strong 和 copy 没有区别，都会将栈上的拷贝到堆上
MRC 下 strong 强引用 copy 会将栈上的拷贝到堆上