Objective-C中block的底层原理

先出2个考题：

1、

上面打印的是几，captureNum2 出去作用域后是否被销毁？为什么？

同样类型的题目：

问：打印的数字为多少？

有人会回答：mutArray是captureObject方法的局部变量，mutArray指针 保存到栈上，那么当执行完captureObject方法后，出去了作用域mutArray变量就会被系统自动释放。

所以当执行captureBlk([[NSObject alloc] init]); 的时候，mutArray为nil，每次打印的为0。

当然上面说的是错的。

打印出来的值分别是 1，2，3。

那么如果把上面代码中的mutArray改为weak类型：

NSMutableArray __weak *mutArray = [[NSMutableArray alloc] init];

结果又会是什么呢。

2、下面代码分别打印的值是多少。为什么？

本文会分析上面的代码中block底层 都做了哪些操作。

用过block的可以 直接忽略前面的语法部分。直接从第三部分看即可。

一、block的使用

iOS4.0开始进入block特性。也叫做闭包。是一个函数（或指向函数的指针），再加上该函数执行的外部的上下文变量（有时候也称作自由变量）。

1、block的声明：

void (^blockName)(int arg1, int arg2);

中文翻译：返回值(^block变量名)(block的参数)

参数名称可以省略，也可以写成：

void (^blockName)(int, int);

2、block的定义：

^void(int arg1, int arg2) {

};

中文翻译：^返回类型(block的参数)

返回类型可以省略，也可以写成：

^(int arg1, int arg2) {};

声明定义和调用：

    void (^blockName)(int, int) = ^(int arg1, int arg2) {
        NSLog(@"arg1 + arg2 = %d", arg1 + arg2);
    };
    blockName(,);

block没有参数、有返回值、作为方法的参数：

- (void)viewDidLoad {
    //2、没有参数
    void (^blockName2)() = ^() {
        NSLog(@"block2");
    };
    blockName2();

    //3、block有返回值
    int (^blockName3)(int) = ^(int n) {
        return n * ;
    };
    //4、block作为方法的参数
    [self testBlock2:blockName3];
}

- (void)testBlock2:(int(^)(int))myBlock {
    myBlock();
}

3、block只有在调用的时候才会执行里面的函数内容。

二、block调用外部变量

1、全局变量，block可以进行读取和修改。

@interface ViewController () {
    NSInteger num;
}

@implementation ViewController

- (void)viewDidLoad {
    //1、block修改成员变量
    void (^block1)() = ^(){
        ++num;
        NSLog(@"调用成员变量： %ld", num);
    };

    block1();
}

2、局部变量，block只能读取，不能修改局部变量。这个时候是值传递。

如果想修改局部变量，要用__block来修饰。这个时候是引用传递。下面会聊下block的实现原理。

看例子：

    //2、调用局部变量，不用__block
    NSInteger testNum2 = ;
    void (^block2)() = ^() {
        //testNum = 1000; 这样是编译不通过的
        NSLog(@"修改局部变量： %ld", testNum2); //打印：10
    };
    testNum2 = ;
    block2();
    NSLog(@"testNum最后的值： %ld", );//打印：30

    //3、修改局部变量，要用__block
    __block NSInteger testNum3 = ;
    void (^block3)() = ^() {
        NSLog(@"读取局部变量： %ld", testNum3); //打印：20
        testNum3 = ;
        NSLog(@"修改局部变量： %ld", testNum3); //打印：1000
    };
    testNum3 = ;
    block3();
    testNum3 = ;
    NSLog(@"testNum最后的值： %ld", testNum3);//打印：30

三、block代码分析

网上很多通过Clang（LLVM编译器）将OC的代码转换成C++源码，来进行分析的。但是这些转换的代码并不是block的源代码，只是用来理解用的过程代码。

1、block不包含任何变量

新建一个testBlock.m文件。文件中代码为：

执行clang命令：

 clang -rewrite-objc testBlock.m

生成.cpp的核心代码主要在.cpp文件的底部，大家可以看下图：

我加了比较详细的注释，具体的看图片就好。这里重点强调下关键的东东：

1.1、其中block的结构体：

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

isa：isa指针，在Objective-C中，任何对象都有isa指针。block 有三种类型：

_NSConcreteGlobalBlock：全局的静态 block，类似函数。如果block里不获取任何外部变量。或者的变量是全局作用域时，如成员变量、属性等； 这个时候就是Global类型

_NSConcreteStackBlock：保存在栈中的 block，栈都是由系统管理内存，当函数返回时会被销毁。__block类型的变量也同样被销毁。为了不被销毁，block会将block和__block变量从栈拷贝到堆。

_NSConcreteMallocBlock：保存在堆中的 block，堆内存可以由开发人员来控制。当引用计数为 0 时会被销毁。

代码执行的时候，block的isa有上面3中值。后面还会进行详细的说明。

1.2、__main_block_func_0 是block要执行的函数：

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
        printf("打印block函数");
}

1.3、__main_block_desc_0 是block的描述信息 的结构体

1.4、block的类型。

在上图中可以看到：

impl.isa = &_NSConcreteStackBlock; 

这里 impl.isa 的类型为_NSConcreteStackBlock，由于 clang 改写的具体实现方式和 LLVM 不太一样，所以这里 isa 指向的还是_NSConcreteStackBlock。但在 LLVM 的实现中，开启 ARC 时，block 应该是 _NSConcreteGlobalBlock 类型。

所以 block是什么类型 在 clang代码里是看不出来的。

如果要查看block的类型还是要通过Xcode进行打印：

打印的结果：

clangBlk = <__NSGlobalBlock__: 0x100054240>
打印block函数

上面block代码，没有获取任何外部变量，应该是 _NSConcreteGlobalBlock类型的。该类型的block和函数一样 存放在 代码段 内存段。内存管理简单。

2、block 访问 局部变量 

新建testBlock2.m文件，代码如下：

通过clang命令生成 的核心代码如下，和刚才clang的代码 不同的地方 已经加了注释：

2.1、可以看到 __main_block_impl_0 中添加了 一个int num的变量。在 __main_block_func_0中使用了该变量。

从这里可以看出来 这里是 值拷贝，不能修改，只能访问。

2.2、用Xcode打印上面block代码，得到的类型为：__NSMallocBlock。

在说_NSConcreteMallocBlock类型前，我们先说下_NSConcreteStackBlock类型。

_NSConcreteStackBlock类型的block存在栈区，当变量作用域结束的时候，这个block和block上的__block变量就会被销毁。

这样当block获取了局部变量，在其他地方访问的时候就会崩溃。block通过copy来解决了这个问题，可以将block从栈拷贝到堆。这样当栈上的作用域结束后，仍然可以访问block和block中的外部变量。

我们现在看下本文开头的问题1：

为什么局部变量muArray出了作用域 还能存在？

captureBlk为默认的__strong类型，当block被赋值给__strong类型的对象或者block的成员变量时，编译器会自动调用block的copy方法。

执行copy方法，block拷贝到堆上，mutArray变量赋值给block的成员变量。所以打印的结果就为1，2，3。

如果把上面代码中的mutArray改为weak类型，那么打印的就都是0了。因为当出去作用域的时候，mutArray就已经被释放了。

同时，因为NSMutableArray *mutArray 是引用类型，用clang命令执行后，发现：

struct __main_block_impl_0
{
    struct __block_impl impl;
    struct __main_block_desc_0 *Desc;
    id __strong mutArray;

    .....

}

mutArray在block中是id类型，因为是指针 所以在block中mutArray是可以修改的，而int类型的不能修改。当然如果用__block也能修改int类型的外部变量，下面我们会详说。

下面这个打印的结果是1，也是这个道理：

同时访问外部变量是block进行的值传递，所以打印的还是1，不是2。

2.3、什么情况下block会进行copy操作。

用代码显示的调用copy操作：

[captureBlk2 copy];

在MRC下block定义的属性都要加上copy，ARC的时候block定义copy或strong都是可以的，因为ARC下strong类型的block会自动完成copy的操作。

@property (nonatomic, strong) captureObjBlk2 captureBlk21;

当 block 作为函数返回值返回时。

当 block 被赋值给 __strong id 类型的对象或 block 的成员变量时。

当 block 作为参数被传入方法名带有 usingBlock 的 Cocoa Framework 方法或 GCD 的 API 时。

3、__block在block中的作用。

新建testBlock3.m，代码如下：

用clang生成的代码如下，进行了详细的注释：

block访问的外部变量，在block中就是一个结构体：__Block_byref_num_0：

// 一、用于封装 __block 修饰的外部变量
struct __Block_byref_num_0 {
    void *__isa;    // 对象指针
    __Block_byref_num_0 *__forwarding;  // 指向 拷贝到堆上的 指针
    int __flags;    // 标志位变量
    int __size;     // 结构体大小
    int num;        // 外部变量
};

其中 int num 为外部变量名。

__Block_byref_num_0 *__forwarding; 这个是指向自己堆上的指针，这个后面会详细说明。

为了对__Block_byref_num_0结构体进行内存管理。新加了copy和dispose函数：

//四、对__Block_byref_num_0结构体进行内存管理。新加了copy和dispose函数。
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {
    // _Block_object_assign 函数：当 block 从栈拷贝到堆时，调用此函数。
    _Block_object_assign((void*)&dst->num, (void*)src->num, /*BLOCK_FIELD_IS_BYREF*/);
}

// 当 block 从堆内存释放时，调用此函数:__main_block_dispose_0
static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->num, /*BLOCK_FIELD_IS_BYREF*/);}

__main_block_impl_0 中增加了 __Block_byref_num_0类型的指针变量。所以__block的变量之所以可以修改 是因为 指针传递。所以block内部修改了值，外部也会改变：

struct __main_block_impl_0 {
    struct __block_impl impl;
    struct __main_block_desc_0* Desc;
    __Block_byref_num_0 *num; // 二、__block int num  变成了 __Block_byref_num_0指针变量。也就是 __block的变量通过指针传递给block
    __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_num_0 *_num, int flags=) : num(_num->__forwarding) {
        impl.isa = &_NSConcreteStackBlock;
        impl.Flags = flags;
        impl.FuncPtr = fp;
        Desc = desc;
    }
};

在block要执行的函数 __main_block_func_0中，我们通过__Block_byref_num_0的__forwarding指针来修改的 外部变量，即：(num->__forwarding->num) = 10;

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
    __Block_byref_num_0 *num = __cself->num; // bound by ref

    (num->__forwarding->num) = ;  //三、这里修改的是__forwarding 指向的内存的值
    printf("num = %d", (num->__forwarding->num));
}

这是为什么呢？

我们先来看下文章开头的第二个问题：

当外部的局部变量testNum3 改变后，block内的testNum3变量也变了。

在block中修改的testNum3值，在block外部testNum3也改变了。

我们看下刚才clang生成的main方法，上面有截图：

类似的逻辑：

用__block修改后，testNum3变量转换为__Block_byref_num_0 的结构体。

上面说过copy操作会将block从栈拷贝到堆上， 会把 testNum3转成的__Block_byref_num_0 结构体  赋值给block的变量。

同时 会把 __Block_byref_num_0 的结构体中的 __forwarding指针指向拷贝到堆上 结构体。

就是栈上和拷贝到堆上的 的__Block_byref_num_0都用__forwarding指向堆上的自己。

这样在栈上修改 testNum3变量的时候，实际修改的是堆上值，所以block内外的值是相互影响。

本来想写下block循环引用的问题。现在写的比较累，明天单开一章来写这个问题吧。

本文中的所有代码还有clang生成的.cpp文件，都放到了github上。

本文参考了MicroCai的文章。

欢迎关注我的 今日头条号 名称： 云端梦想科技

欢迎关注我的 微信公众号：dreams2999