Block

1、Block
2、捕获变量
3、__block
4、Block内存管理
5、Block的循环引用

  • 将函数及其执行上下文（函数执行环境）封装起来的对象
  • Block内部有isa 指针，所以说其本质也是OC对象
  • Block的调用即是函数的调用

1、Block

新建MCBlock添加方法

- (void)method
{
    int multiplier = 6;
    int(^Block)(int) = ^int(int num){
        return  num * multiplier;
    };
    Block(2);
}

使用clang编译器编译 clang -rewrite-objc MCBlock.m -o MCBlock.cpp 将代码转换成C++源码，会生成MCBlock.cpp的C++文件，都是被编译为C语言里的普通struct结构体来实现的，编译后的代码:

_I_MCBlock_method
static void _I_MCBlock_method(MCBlock * self, SEL _cmd) {
    int multiplier = 6;
    int(*Block)(int) = ((int (*)(int))&__MCBlock__method_block_impl_0((void *)__MCBlock__method_block_func_0, &__MCBlock__method_block_desc_0_DATA, multiplier));
    ((int (*)(__block_impl *, int))((__block_impl *)Block)->FuncPtr)((__block_impl *)Block, 2);
}

block的定义声明部分

int(*Block)(int) = ((int (*)(int))&__MCBlock__method_block_impl_0((void *)__MCBlock__method_block_func_0, &__MCBlock__method_block_desc_0_DATA, multiplier));

__MCBlock__method_block_impl_0 结构体参数
(void *)__MCBlock__method_block_func_0：void*类型函数指针
&__MCBlock__method_block_desc_0_DATA：block相关描述
multiplier：被block使用的局部变量

结构体 __MCBlock__method_block_impl_0
struct __MCBlock__method_block_impl_0 {
  struct __block_impl impl;
  struct __MCBlock__method_block_desc_0* Desc;
  int multiplier;
  //c++中对结构体构造函数的声明或者定义
  __MCBlock__method_block_impl_0(void *fp, struct __MCBlock__method_block_desc_0 *desc, int _multiplier, int flags=0) : multiplier(_multiplier) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags; //标记位
    impl.FuncPtr = fp; //函数指针
    Desc = desc;  //block描述
  }
};

__MCBlock__method_block_impl_0结构体对应了Block的定义
通常包含两个结构体成员变量（impl、Desc）和一个同名构造函数
int multiplier其实是被捕获的变量
multiplier(_multiplier)：_multiplier直接赋值给结构体中的同名变量

__block_impl

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

isa：isa指针，Block是OC对象的标志，isa指针指向一个对象，有三种类型_NSConcreteStackBlock、_NSConcreteGlobalBlock、_NSConcreteMallocBlock
FuncPtr：函数指针

__MCBlock__method_block_func_0

Block执行时调用的函数

static int __MCBlock__method_block_func_0(struct __MCBlock__method_block_impl_0 *__cself, int num) {
  int multiplier = __cself->multiplier; // bound by copy
        return num * multiplier;
    }

Block花括号中定义的执行体，最终会产生一个函数，Block通过函数指针指向对应函数实现

__MCBlock__method_block_desc_0
static struct __MCBlock__method_block_desc_0 {
  size_t reserved; //系统保留值
  size_t Block_size;  //Block的大小
} __MCBlock__method_block_desc_0_DATA = { 0, sizeof(struct __MCBlock__method_block_impl_0)};
Block调用
((int (*)(__block_impl *, int))((__block_impl *)Block)->FuncPtr)((__block_impl *)Block, 2);

对Block进行强制类型转换(__block_impl *)Block，取出成员变量FuncPtr，通过函数指针找到了函数执行体，传递参数，第一个参数是Block本身

2、捕获变量

  • Block捕获值，内部结构体会新增同名成员变量，保存传进来的值
  • 对基本数据类型的局部变量捕获其值
  • 对于对象类型的局部变量连同所有权修饰符一起截获
  • 以指针形式截获静态局部变量
  • 不截获全局变量、静态全局变量 
- (void)method {
    int multiplier = 6;
    int(^Block)(int) = ^int(int num){
        return  num * multiplier;
    };
    multiplier = 4;
    NSLog(@"result is %d", Block(2)); //12
}
  • 解析
//全局变量
int global_var = 4;
//静态全局变量
static int static_global_var = 5;

- (void)method
{
    //基本数据类型局部变量
    int var = 1;
    //对象类型局部变量
    __unsafe_unretained id unsafe_obj = nil;
    __strong id strong_obj = nil;
    //静态局部变量
    static int static_var = 3;
    void(^Block)(void) = ^(void) {
        NSLog(@"局部变量<基本数据类型> var %d", var);
        NSLog(@"局部变量<__unsafe_unretained 对象类型> var %@", unsafe_obj);
        NSLog(@"局部变量<__strong 对象类型> var %@", strong_obj);
        NSLog(@"静态变量 %d", static_var);
        NSLog(@"全局变量 %d", global_var);
        NSLog(@"静态全局变量 %d", static_global_var);
    };
    Block();
}

clang -rewrite-objc -fobjc-arc MCBlock.m

int global_var = 4;
//对全局变量、静态全局变量不截获
static int static_global_var = 5;

struct __MCBlock__method_block_impl_0 {
  struct __block_impl impl;
  struct __MCBlock__method_block_desc_0* Desc;
  int var; //捕获局部变量
  __unsafe_unretained id unsafe_obj;//连同所有权修饰符一起截获
  __strong id strong_obj;
  int *static_var; //以指针针形式截获静态局部变量
  __MCBlock__method_block_impl_0(void *fp, struct __MCBlock__method_block_desc_0 *desc, int _var, __unsafe_unretained id _unsafe_obj, __strong id _strong_obj, int *_static_var, int flags=0) : var(_var), unsafe_obj(_unsafe_obj), strong_obj(_strong_obj), static_var(_static_var) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

3、__block

一般情况下，对被截获变量进行赋值操作需要添加__block修饰符
基本数据类型和对象类型的局部变量进行赋值时需要加__block修饰符
静态局部变量、静态全局变量、全局变量进行赋值时不需要加__block修饰符

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        __block int multiplier = 6;
        int(^Block)(int) = ^int(int num){
            return  num * multiplier;
        };
        multiplier = 4;
        NSLog(@"result %d", Block(2));//8
    }
    return 0;
}

__block int multiplier = 6 经过编译器之后

__attribute__((__blocks__(byref))) __Block_byref_multiplier_0 multiplier = {(void*)0,(__Block_byref_multiplier_0 *)&multiplier, 0, sizeof(__Block_byref_multiplier_0), 6};

__block int multiplier编译之后，有isa，__block修饰的变量变成了对象

struct __Block_byref_multiplier_0 {
  void *__isa;
__Block_byref_multiplier_0 *__forwarding;
 int __flags;
 int __size;
 int multiplier;
};

multiplier = 4 经过编译之后

(multiplier.__forwarding->multiplier) = 4

通过multiplier对象当中的__forwarding指针找到对应的一个对象，然后对其成员变量multiplier进行值的赋值

截屏2020-09-28 上午11.25.50.png

栈上创建的 __forwarding指针指向自己（如果没有copy操作）

4、Block内存管理

Block的类型
_NSConcreteGlobalBlock（NSGlobalBlock） 全局Block，存放在已初始化数据区（.data），没有访问auto变量
_NSConcreteStackBlock（NSStackBlock） 栈Block，存放在栈区，没有访问auto变量
_NSConcreteMallocBlock（NSMallocBlock） 堆Block，存放在堆区，NSStackBlock调用了copy
不使用外部变量的Block是全局Block
使用外部变量并且未进行copy操作的Block是栈Block
对栈Block进行copy操作，就是堆Block，对全局Block进行copy，仍是全局Block

Block的Copy操作
截屏2020-09-27 下午6.00.33.png

对栈上Block进行copy操作，copy结果->在堆上产生一个Block

截屏2020-09-28 上午11.55.11.png

对栈上__block变量copy操作后，栈上的__forwarding指针指向堆上的__block变量，堆上的__forwarding指向其自身

  • __forwarding存在意义
    不论在任何内存位置，都可以顺利的访问同一个__block变量

5、Block的循环引用

@property (nonatomic, strong) NSMutableArray *array;
@property (nonatomic, copy) NSString *(^strBlk)(NSString *);

_array = [NSMutableArray arrayWithObject:@"block"];
_strBlk = ^NSString*(NSString *num){
    return  [NSString stringWithFormat:@"hello_%@", _array[0]];
};
_strBlk(@"hello");
截屏2020-09-28 下午4.55.36.png

当前对象是通过copy属性关键字声明的Block，当前对象对这Block有强引用；Block表达式当中使用到了_array成员变量，对象类型的成员变量会连同其属性关键字一起捕获，_array是通过strong修饰的，所以Block内部就有个strong类型的指针指向当前对象

避免循环引用

__weak NSArray *weakArray = _array;
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。