深入了解Block的奥秘

前言

block可以叫回调代码块，是iOS开发中至关重要的形式之一。不同的编程语言都会用到block, 只是体现形式有所不同，例如c/c++叫函数指针，javascript叫它闭包。它用简单的方式帮我们解决了很多复杂的问题。但是还是一些区别：

• block的代码是内联的，效率高于函数调用
• block对于外部变量默认是只读属性
• block被Objective-C看成是对象处理
• block可读性更高，相比于delegate思路不会打断

block初识

先从一个简单的需求来说：传入两个数，并且计算这两个数的和，为此创建了这样一个block：

int (^sum)(int a, int b) = ^(int a, int b) {
    return a + b;
};

783864-3ad5d92333756aa7 (1).jpeg

block如何将变量传递及持有

测试代码：

传递原则：

1. 捕获对象是基础类型变量，如int, double类型时，是值传递。
2. 只有用__block修饰，变量才可以被修改，可以理解为指针传递。

我们来验证一下，变量a能否在block赋值之后被修改

    int a = 10;
    _foo.testBlock= ^() {
        _testView.backgroundColor = nil;//持有了self
        NSLog(@"a:%d", a);//10还是20？
    };
    a+= 10;
    _foo.testBlock();//block调用

输出结果: 10，它没有被外界改变。
表面上看起来block里面的a和外面的a一个东西，但实际上相当于生成了一个新的变量a' = a; 所以a值改变,a'不会跟着变；a'值改变，a也不会变。
解决方法：可以__block来修饰int a，也就是

__block int a = 10

最终a的值就是20，它被外界改变了，__block帮我们了解决问题。

但是Why? block内部是以什么形式存在，并捕获值的呢？接下来我们要一探究竟。

准备工作:clang命令

大家可以用clang(或者gcc) -rewrite-objc xxxxx.m命令来查看转化成的c++代码来了解内幕。如果你引用了UIKIt库，这个命令会报错，那个因为命令里没有指定sdk的版本，此时用下面的命令完美解决：

clang -x objective-c -rewrite-objc -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator.sdk ViewController.m

__block的奥秘

不带__block的代码转化为cpp代码：

    int a = 10;
    ((void (*)(id, SEL, void (*)()))(void *)objc_msgSend)((id)(*(Foo **)((char *)self + OBJC_IVAR_$_ViewController$_foo)), sel_registerName("setTestBlock:"), ((void (*)())&__ViewController__viewDidLoad_block_impl_0((void *)__ViewController__viewDidLoad_block_func_0, &__ViewController__viewDidLoad_block_desc_0_DATA, self, a, 570425344)));

    a+= 10;

    ((void (*(*)(id, SEL))())(void *)objc_msgSend)((id)(*(Foo **)((char *)self + OBJC_IVAR_$_ViewController$_foo)), sel_registerName("testBlock"))();

带__block的代码转化为cpp代码：

__attribute__((__blocks__(byref))) __Block_byref_a_0 a = {(void*)0,(__Block_byref_a_0 *)&a, 0, sizeof(__Block_byref_a_0), 10};//对a的封装进行初始化

    ((void (*)(id, SEL, void (*)()))(void *)objc_msgSend)((id)(*(Foo **)((char *)self + OBJC_IVAR_$_ViewController$_foo)), sel_registerName("setTestBlock:"), ((void (*)())&__ViewController__viewDidLoad_block_impl_0((void *)__ViewController__viewDidLoad_block_func_0, &__ViewController__viewDidLoad_block_desc_0_DATA, self, (__Block_byref_a_0 *)&a, 570425344)));//这里把封装的结构体的地址传递了进去

    (a.__forwarding->a)+= 10;//a+10

        ((void (*(*)(id, SEL))())(void *)objc_msgSend)((id)(*(Foo **)((char *)self + OBJC_IVAR_$_ViewController$_foo)), sel_registerName("testBlock"))();

__Block_byref_a_0的定义如下, 它对a进行了封装

struct __Block_byref_a_0 {
  void *__isa;
__Block_byref_a_0 *__forwarding;
 int __flags;
 int __size;
 int a;//---->它就是传递进来的a
};

我们发现编译器把int a封装成了一个叫__Block_byref_a_0的结构体，int a只是个迷惑人的假象，所有对a的操作都是对结构体的操作。并且用&符号将结构体的地址传递给了block，所以后面a被修改时，block里面的结构体的a也被同时修改。

Block的父子层级关系及常见类别

1.我们可以打印一个Global block的类及父类的名字：(这段代码摘自facebook的FBRetainCycleDetector)

static Class _BlockClass() {
  static dispatch_once_t onceToken;
  static Class blockClass;
  dispatch_once(&onceToken, ^{
    void (^testBlock)() = [^{} copy];
    blockClass = [testBlock class];
    while(class_getSuperclass(blockClass) && class_getSuperclass(blockClass) != [NSObject class]) {
      blockClass = class_getSuperclass(blockClass);
    }
    [testBlock release];
  });
  return blockClass;
}

结果是 **NSObject -> NSBlock ->__NSGlobalBlock **
事实上block有三种形式：

• __NSGlobalBlock 全局 （未捕获变量）
• __NSStackBlock 栈 捕获变量
• __NSMallocBlock 堆 捕获变量

在 ARC 中，捕获外部了变量的 block 的类会是 NSMallocBlock 或者 NSStackBlock，如果 block 被赋值给了某个变量在这个过程中会执行 _Block_copy 将原有的 NSStackBlock 变成 NSMallocBlock；但是如果 block 没有被赋值给某个变量，那它的类型就是 NSStackBlock；没有捕获外部变量的 block 的类会是 NSGlobalBlock 即不在堆上，也不在栈上，它类似 C 语言函数一样会在代码段中。

2.那什么时候在堆上，什么时候在栈上呢？
在ARC有效时，大多数情况下编译器会进行判断，自动生成将Block从栈上复制到堆上的代码，以下几种情况栈上的Block会自动复制到堆上：

1. 调用Block的copy方法
2. 将Block作为函数返回值时
3. 将Block赋值给__strong修改的变量时
4. 向Cocoa框架含有usingBlock的方法或者GCD的API传递Block参数时

3.block用strong修饰还是copy修饰呢？
实际上调用retain方法时, block会调用copy方法，所以这两种修饰是相同的。但是为了语义的明确，推荐用copy修饰。

 self.testBlock = ^() {
 }

反编译代码（也可以打断点，切换到汇编模式查看汇编代码）

 void -[Foo setTestBlock:](void * self, void * _cmd, void * arg2) {
 objc_storeStrong(var_18, arg2);
 rax = objc_retainBlock(0x0);
 rdi = self->_testBlock;
 self->_testBlock = rax;
 [rdi release];
 objc_storeStrong(0x0, 0x0);
 return;
 }

runtime源码如下，实际上还是调用了block_copy方法

id objc_retainBlock(id x) {
    return (id)_Block_copy(x);
}

循环引用

开头说过，block在iOS开发中被视作是对象，因此其生命周期会一直等到持有者的生命周期结束了才会结束。另一方面，由于block捕获变量的机制，使得持有block的对象也可能被block持有，从而形成循环引用，导致两者都不能被释放:

    self.foo.testBlock= ^() {
        self.view.backgroundColor = nil;//持有了self
        NSLog(@"a:%d", a);//10还是20？
    };

严格意义上讲循环引用是因为形成了一个环状引用，参与者可能是多个，并非只有2个，这会造成这个环上的所有对象都无法被释放。

解决方法：用__weak来修饰对象，这样对象被捕获后不会被强引用，引用计数器不发生变化，然后在真正用要到的时候再strong强引用，防止在使用过程中对象突然释放

    __weak __typeof__ (self) wself = self;
    self.foo.testBlock = ^() {
        __strong __typeof (wself) sself = wself;
        sself.view.backgroundColor = [UIColor whiteColor];
    };

结语

还是那句话：源码下面无秘密。
苹果底层对于block实现真是煞费苦心。我们了解了原理，用起来会更加得深应手。