【iOS重学】Block底层原理（一）

写在前面

关于Block的底层原理相关东西，需要了解的东西比较多，所以博主这里打算用两篇文章来详细分析一下OC里面的Block，这是第一篇，内容主要包含：

Block的基本使用
Block的底层数据结构
Block对变量的捕获
Block的类型

好了，废话少说，现在跟着博主开始从头了解Block吧。

Block的基本使用

// 定义一个Block
void(^WWBlock)(void) = ^{
    NSLog(@"This is a block...");
};
        
// 调用Block
WWBlock();

以上是最简单的一个Block，调用Block()会打印：This is a block...。

// Person 类
@interface Person : NSObject

- (void)fetchDataWithSuccess:(void(^)(NSString *message))successBlock;

@end

@implementation Person

- (void)fetchDataWithSuccess:(void(^)(NSString *message))successBlock {
    if (successBlock) {
        successBlock(@"这是一个成功的回调...");
    }
}

@end

// 使用
Person *person = [[Person alloc] init];
[person fetchDataWithSuccess:^(NSString *message) {
    NSLog(@"---- %@", message);
}];

// 打印结果：
2022-12-06 19:30:08.775142+0800 BlockDemo[53402:5642770] ---- 这是一个成功的回调...

相信这种类似的Block大家在日常项目中会看到很多很多，我们这里就不再一一列举了。

Block的底层数据结构

// 定义一个Block
void(^WWBlock)(void) = ^{
    NSLog(@"This is a block...");
};
        
// 调用Block
WWBlock();

我们来看一下上面最简单的Block的底层C++结构是什么样的，使用命令xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m -o main.cpp转为C++代码如下：

int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
        // 定义Block
        void(*WWBlock)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
                            
        // 调用Block               
        ((void (*)(__block_impl *))((__block_impl *)WWBlock)->FuncPtr)((__block_impl *)WWBlock);
    }
    return 0;
}

把相应的强制转换给去掉能够帮助我们更清晰的理解Block的结构，去掉一些强制转换之后如下：

// 定义Block
void(*WWBlock)(void) = &__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA));
// 调用Block      
WWBlock->FuncPtr(WWBlock);

可以看到跟Block相关的有：__main_block_impl_0、__main_block_func_0、__main_block_dec_0_DATA这几个类，在生成的C++文件里面找到相关的结构如下：

从上面的图里面我们可以看到，Block的结构里面也有一个isa指针，所以Block的本质其实也是一个【OC对象】，是一个封装了函数调用及其调用环境的OC对象。

对应关系如下图所示：

在调用的时候WWBlock->FuncPtr(WWBlock)，相当于是拿到WWBlock结构里面的函数指针FuncPtr去调用对应的方法，这个函数指针里面其实存放的就是Block代码块的地址。

Block对变量的捕获

为什么Block会对变量进行捕获？

因为在Block里面可能需要访问Block外部变量的值，所以需要捕获（capture）变量保证我们能正确访问到变量。

我们现在分别来分析【auto变量】、【static变量】、【全局变量】三种不同的变量，Block对其捕获是不是也不一样呢？

auto变量

auto变量：离开当前作用域就会销毁的变量。

1、非对象类型的auto变量

// 定义一个Block
int age = 10;
void(^WWBlock)(void) = ^{
    NSLog(@"对auoto变量的捕获 - %d",age);
};
age = 20;

// 调用Block
WWBlock();

// 打印结果：
2022-12-06 20:18:28.957166+0800 BlockDemo[54326:5689813] 对auoto变量的捕获 - 10

底层C++代码如下：

跟前面我们没有捕获变量相比，会把age传递到Block里面：

从底层结构我们也看到了：Block会对auto变量进行捕获，访问的方式是【值传递】。

2、对象类型的auto变量

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        void(^WWBlock)(void);
        {
            Person *person = [[Person alloc] init];
            person.age = 10;
            WWBlock = ^{
                NSLog(@"person's age is %d",person.age);
            };
        }
        NSLog(@"-----");
        WWBlock();
    }
    return 0;
}

// 打印结果：
2022-12-07 15:45:31.593895+0800 BlockDemo[2248:6132111] -----
2022-12-07 15:45:31.594542+0800 BlockDemo[2248:6132111] person's age is 10
2022-12-07 15:45:31.594693+0800 BlockDemo[2248:6132111] -[Person dealloc]

底层结构代码如下：

对照上面的底层数据结构发现：多了两个函数__main_block_copy_0和__main_block_dispose_0。

当Block被拷贝到堆上时，会调用Block内部的copy函数__main_block_copy_0，函数里面调用_Block_object_assign，在_Block_object_assign里面根据auto变量的修饰符做出相应的操作：强引用或弱引用。

当Block从对上移除时，会调用Block内部的dispose函数__main_block_dispose_0，函数里面调用_Block_object_dispose，_Block_object_dispose去对引用的auto变量进行一次release操作。

在使用clang转换OC为C++代码时，如果有__weak可能会出现下面报错：

让其支持ARC、指定运行时系统版本即可，比如：

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

static变量

static变量：离开当前作用域不会销毁的变量。

// 定义一个Block
static int age = 10;
void(^WWBlock)(void) = ^{
    NSLog(@"对static变量的捕获 - %d",age);
};
age = 20;

// 调用Block
WWBlock();

// 打印结果：
2022-12-06 20:27:55.716204+0800 BlockDemo[54594:5700817] 对static变量的捕获 - 20

底层C++代码如下：

从底层结构我们也看到了：Block会对static变量进行捕获，访问的方式是【指针传递】。

全局变量

int age;
int main(int argc, const char * argv[]) {
  @autoreleasepool {
      // 定义一个Block
      age = 10;
      void(^WWBlock)(void) = ^{
          NSLog(@"age is %d",age);
      };
      age = 20;
      // 调用Block
      WWBlock();

  }
  return 0;
}

// 打印结果：
2022-12-07 13:39:45.012065+0800 BlockDemo[197:6032120] age is 20

底层C++代码如下：

从底层结构我们发现：Block不会对全局变量进行捕获，直接访问全局变量即可。

思考：

1、为什么Block不会捕获全局变量，但是局部变量需要捕获？

全局变量在任何时候任何地方都是可以访问到的，因此不需要捕获可以直接访问。

局部变量因为作用域的问题需要被捕获，保证Block内部能够正确访问到该变量。

2、Block会对捕获self吗？

会，说明self是个局部变量。

- (void)test {
    self.age = 10;
    void(^WWBlock)(void) = ^{
        NSLog(@"age is %d", self.age);
    };
    WWBlock();
}

底层C++代码如下：

self和_cmd其实是两个隐式参数，所以我们能在里面正常访问self、_cmd。

Block捕获变量总结

Block的类型

void(^block1)(void) = ^{
   NSLog(@"This is block...");
};

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

NSLog(@"%@ %@ %@",[block1 class],[block2 class],[^{NSLog(@"age is %d", age);} class]);
NSLog(@"%@ %@ %@",[[block1 class] superclass], [[block2 class] superclass], [[^{NSLog(@"age is %d", age);} class] superclass]);

// 打印结果：
2022-12-07 15:40:29.626370+0800 BlockDemo[2188:6126897] __NSGlobalBlock__ __NSMallocBlock__ __NSStackBlock__
2022-12-07 15:40:29.627050+0800 BlockDemo[2188:6126897] NSBlock NSBlock NSBlock