iOS源码解析

来聊聊Block(二)

2017-04-08  本文已影响128人  Neo_joke

上一篇 文章 简要解释了Block的基本概念，打一些基础，从而能够更好的了解关于编程语言中类似于Objective-C Block这种块级逻辑单元的语法本质，其实在编程语言通用的概念中，类似于Block这种的语法被称为lambda表达式，也被称为匿名函数，也就是不需要定义函数名的函数或者是子程序，在很多现代化的高级语言中都普遍存在，比方说Java8中通过箭头函数来实现lambda表达式，消除了以前被广为诟病的通过接口实例化内部类来实现类似于lambda的handler。JavaScript因为函数本身就是一等公民，可以进行传递，自然也就支持匿名的函数作为参数，作为变量。Python支持lambda关键字，实现匿名参数，非常简单，但只能实现一些简单的函数。C++、C#也都实现了lambda表达式，Swift、Ruby则强调闭包的概念，本质上与lambda表达式是同样一种东西。
那对于Block来说，我们要抓住其核心本质的东西，才能避免各类语言在这方面的技术陷阱，才能触类旁通，提高效率。

为什么在@property(nonatomic,copy)void(^block)(void)声明Block变量使用copy？

在编写日常业务代码时，一种常用的范式就是异步执行任务，或者说是handler回调。这种需求往往可以通过调用方设置block从而代替繁琐的delegate模式，但被调用方一般都需要持有这个block，则经常会声明一个block的属性，而一般@property中则经常使用copy关键字，我们来看一下具体的原因。
上一篇我们提到有一种block是栈Block，在局部声明的Block就是这种，随着作用域的消失而出栈，从而消失，那么，当调用方声明一个block传入被调用方进行持有的时候，则需要将栈区的block拷贝到堆区，所以才使用copy，但是在ARC中写不写都行，因为ARC会自动copy，从而保证block的安全调用。大家都使用copy来声明，则是一种习惯，当然这种习惯是非常好的，至少，如果被调用方不声明copy，调用方有可能会自己再调用copy从而多此一举。官方的详细原因解释如下：
Objects Use Properties to Keep Track of Blocks

Block的值捕获

对于函数与方法，最明显的区别莫过于函数是无状态的，而方法是有上下文依赖的，而这个上下文则是由对象内部的状态和数据组合提供的。Block或者是lambda表达式，之所以能够使用到诸如异步执行任务或者说是回调中，原因就在于它方便的能够引用上下文的内容，而这个上下文则是Block声明的地方所在的上下文，这也是这种块级语法相对于其他语法比较难以掌握的地方，而如何引用上下文的内容，这个话题被称为作用域的值捕获问题(scope capture value)。
如果Block没有引用上下文以外的任何东西，那么这个问题也就不用讨论，那么单纯考虑引用上下文内容的情况，可以划分为两类情况：

  1. 只引用不修改
  2. 既引用又修改

只引用，不修改：

对于在block内部引用上下文当中的变量，可以分为值类型和引用类型，值类型就是，不管怎样在上下文中传递，只传递该变量的值，比如int、char等这些基本数据类型，引用类型其实指的就是指针，这种不传递变量实际的值，而只传递指向该变量内存地址的指针，其实指针的内容本质上也是基本数据类型，属于值类型，对于值类型，block对其引用就是直接将该变量的值给复制一遍到block内部，方便以后使用。例子如下：

-(void)whatisblock{
    int count = 0;
    void(^block)(void);
    NSString * testString = @"test block";
    block = ^(){
        NSLog(@"%@ %d", testString, count);
    };
    block();
}

block中捕获了count变量与testString变量，一个是int类型的值类型，一个是指向NSString类型的指针类型，也就是引用类型。通过clang 编译成C++代码以后，可以发现：

//whatisblock方法的实现
static void _I_TestBlock_whatisblock(TestBlock * self, SEL _cmd) {
    int count = 0;//局部变量，值类型
    void(*block)(void);
    NSString * testString = (NSString *)&__NSConstantStringImpl__var_folders_rk_qz09dkwd485dfckp9sxb63ph0000gn_T_TestBlock_c39702_mi_1;//局部变量，引用类型，但是@"test block"是个常量，所以实质上是一个静态变量
    block = ((void (*)())&__TestBlock__whatisblock_block_impl_0((void *)__TestBlock__whatisblock_block_func_0, &__TestBlock__whatisblock_block_desc_0_DATA, testString, count, 570425344));
    ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
    NSNumber * num = ((NSNumber *(*)(Class, SEL, int))(void *)objc_msgSend)(objc_getClass("NSNumber"), sel_registerName("numberWithInt:"), 0);
    void(*stackBlock)(void) =((void (*)())&__TestBlock__whatisblock_block_impl_1((void *)__TestBlock__whatisblock_block_func_1, &__TestBlock__whatisblock_block_desc_1_DATA, num, 570425344));
    ((void (*)(__block_impl *))((__block_impl *)stackBlock)->FuncPtr)((__block_impl *)stackBlock);
    Class blockClass = object_getClass((id)stackBlock);
    NSLog((NSString *)&__NSConstantStringImpl__var_folders_rk_qz09dkwd485dfckp9sxb63ph0000gn_T_TestBlock_c39702_mi_4,NSStringFromClass(blockClass));
}

struct __TestBlock__whatisblock_block_impl_0 {
  struct __block_impl impl;
  struct __TestBlock__whatisblock_block_desc_0* Desc;
  NSString *testString;//直接引用指针的值
  int count;//直接复制值类型的值
  __TestBlock__whatisblock_block_impl_0(void *fp, struct __TestBlock__whatisblock_block_desc_0 *desc, NSString *_testString, int _count, int flags=0) : testString(_testString), count(_count) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

从__TestBlock__whatisblock_block_impl_0block的结构体中发现，block捕获的上下文的变量都会在结构体中声明为成员变量，在初始化block的时候，将值类型的count变量直接复制到自己的结构体中，将引用的指针的值也直接复制到自己的结构体中，但是通过指针引用捕获到的引用类型testString，当然，ARC情况下如果是引用类型，会直接操作引用计数从而保证变量不会被销毁从而保证能够安全访问。
总结一下:

  1. block捕获的值类型，会直接复制变量的值
  2. block捕获的引用类型，会直接复制引用的指针的值，根据指针的类型，使用ARC进行内存管理，保证block访问引用类型的引用
  3. 如果能确定引用类型在block执行的生命周期内一直存在，则可以使用__weak来告知ARC不增加引用计数，破除Block的retain cycle就是基于这个原理
  4. 如果捕获的是全局变量或者是静态变量或者是静态全局变量，则根据是否可以安全访问到的原则，相应的进行指针复制，不受ARC影响，大家可以自己做个实验，来验证一下这些类型的变量如何进行捕获的

对于捕获变量来说，诸如block和lambda表达式要解决的一个核心问题就是如何保证能够安全的访问到之前捕获到的变量，如果是值类型，则直接复制，从而保证能够安全引用，如果是引用类型，则通过本门语言的内存管理模型来保证能够正确的捕获上下文的变量从而能够安全访问，那么这种技术的核心要义在于语言对作用域(scope)的上下文捕获原则和内存管理模式。

既引用，又修改

Block引用的方式已经非常清楚，那么对于修改则需要着重研究一下：

//warning: Variable is not assignable (missing __block type specifier)
int count = 0;
    void(^block)(void);
    block = ^(){
        count = 10;
        NSLog(@"%d", count);
    };

这种写法会导致编译器报错，提示为变量不是可被引用的，因为count的作用域在当前方法体内，变量在栈内，随着方法调用结束，出栈变量销毁，则block内无法引用修改，那么根据提示需要在需要修改的变量之前加上__block.

//warning: Variable is not assignable (missing __block type specifier)
       __block int count = 0;
    void(^block)(void);
    block = ^(){
        count = 10;
        NSLog(@"%@ %d", testString, count);
    };

再编译一下源码，看一下

struct __TestBlock__whatisblock_block_impl_0 {
  struct __block_impl impl;
  struct __TestBlock__whatisblock_block_desc_0* Desc;
  __Block_byref_count_0 *count; // by ref
  __TestBlock__whatisblock_block_impl_0(void *fp, struct __TestBlock__whatisblock_block_desc_0 *desc, __Block_byref_count_0 *_count, int flags=0) : count(_count->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __TestBlock__whatisblock_block_func_0(struct __TestBlock__whatisblock_block_impl_0 *__cself) {
  __Block_byref_count_0 *count = __cself->count; // bound by ref

        (count->__forwarding->count) = 10;
        NSLog((NSString *)&__NSConstantStringImpl__var_folders_rk_qz09dkwd485dfckp9sxb63ph0000gn_T_TestBlock_7b0cc2_mi_1, (count->__forwarding->count));
    }
// @implementation TestBlock
struct __Block_byref_count_0 {
  void *__isa;
__Block_byref_count_0 *__forwarding;
 int __flags;
 int __size;
 int count;
};
static void _I_TestBlock_whatisblock(TestBlock * self, SEL _cmd) {
    __attribute__((__blocks__(byref))) __Block_byref_count_0 count = {(void*)0,(__Block_byref_count_0 *)&count, 0, sizeof(__Block_byref_count_0), 0};
    void(*block)(void);
    block = ((void (*)())&__TestBlock__whatisblock_block_impl_0((void *)__TestBlock__whatisblock_block_func_0, &__TestBlock__whatisblock_block_desc_0_DATA, (__Block_byref_count_0 *)&count, 570425344));
    ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);

}

与单纯捕获相比，如果修改了count，则__block会将变量重写为一个结构体，类型为

struct __Block_byref_count_0 {
  void *__isa;//isa指针，指向类型
__Block_byref_count_0 *__forwarding; //指向自己所在的内存地址
 int __flags;
 int __size;
 int count;//原值
};

为了能够使方法体内声明的变量不因出栈而销毁，则将count转换为结构体，复制到堆上，在static void __TestBlock__whatisblock_block_func_0函数体内，则通过count->__forwarding->count来访问。这么做是因为在栈上的count的结构体变量，其__forwarding指向被复制到堆上的count内存，而在堆上的count变量的__forwarding又指向自身，所以通过count->__forwarding->count访问能一直访问堆上的count变量。
从以上的分析来看这样一个规律，如果要修改捕获的上下文的变量，则需要通过重新构建引用变量的结构体类型，通过ARC复制到堆上，修改完引用计数以后就可以安全访问，但是如果出现相互引用的情况，则因为ARC在复制到堆的情况下会增加引用计数，就会出现retain环的问题，所以，如果是相互持有，被引用的变量如果在block的生命周期内一直存在，则可以通过__weak来取消ARC的引用计数操作，这样也是能够保证被捕获的变量的安全的。
最终，通过了解值类型和引用类型在block作用域内的引用方式，再通过研究如果修改局部变量引用方式如何改变，block内的引用和修改，可以更加清楚的通过ARC来解释这些现象。

Block的内存管理

本文一直讨论的都是ARC的情况，在MRC的情况下，上述讨论的结果又极大的不同，因为MRC的方式是完全C的内存管理方式，需要主动调用copy或者是栈与堆的内存拷贝，而在ARC情况下，只需要记忆Block捕获的变量为了能够在Block的生命周期内安全引用，ARC会自动copy和引用计数提升来达到持有变量，当然需要注意的就是ARC接管以后出现的Block循环引用问题。

总结：

  1. Block在Objective-C中的实现，依赖于其内存管理方式，使得block能够捕获的上下文变量能够被安全引用，但也要注意单一的引用计数可能引起的相互引用问题
  2. 在Swift中，闭包也是如此，闭包能够捕获的上下文变量和内存管理方式基本上也是ARC的常规表现，所以可以通过弱引用或者无主引用破除循环引用
  3. 在使用GC(垃圾回收)的语言中，lambda表达式不存在循环引用的问题，因为除了引用计数，GC还有标记、分代、计划清理、引用更新等来消除循环引用，例如Python和C#都不存在像Block这样的问题
上一篇下一篇

猜你喜欢

热点阅读