Objective-C中block的底层原理

先出2个考题：

一、

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

 

一样类型的题目：

 

问：打印的数字为多少？

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

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

 

固然上面说的是错的。

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

那么若是把上面代码中的mutArray改成weak类型：

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

结果又会是什么呢。

 

二、下面代码分别打印的值是多少。为何？

 

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

 

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

 

1、block的使用

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

一、block的声明：

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

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

参数名称能够省略，也能够写成：

void (^blockName)(int, int);

 

二、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(1,2);

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

- (void)viewDidLoad {
    //二、没有参数
    void (^blockName2)() = ^() {
        NSLog(@"block2");
    };
    blockName2();
    
    //三、block有返回值
    int (^blockName3)(int) = ^(int n) {
        return n * 2;
    };
    //四、block做为方法的参数
    [self testBlock2:blockName3];
}

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

  

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

 

2、block调用外部变量

一、全局变量，block能够进行读取和修改。

@interface ViewController () {
    NSInteger num;
}

@implementation ViewController

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

 

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

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

看例子：

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

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

 

3、block代码分析

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

一、block不包含任何变量

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

 

执行clang命令：

 clang -rewrite-objc testBlock.m

生成.cpp的核心代码主要在.cpp文件的底部，你们能够看下图：

 

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

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.二、__main_block_func_0 是block要执行的函数：

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

 

1.三、__main_block_desc_0 是block的描述信息 的结构体

1.四、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和函数同样 存放在 代码段 内存段。内存管理简单。

 

二、block 访问 局部变量 

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

 

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

2.一、能够看到 __main_block_impl_0 中添加了 一个int num的变量。在 __main_block_func_0中使用了该变量。

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

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.三、什么状况下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 时。

 

三、__block在block中的做用。

新建testBlock3.m，代码以下：

 

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

 

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

// 1、用于封装 __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函数：

//4、对__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, 8/*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, 8/*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; // 2、__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=0) : 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) = 10;  //3、这里修改的是__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