前言

之前,咱们在探求动画及烘托相关原理的时分,咱们输出了几篇文章,解答了iOS动画是怎么烘托,特效是怎么工作的疑问。咱们深感体系设计者在创作这些体系结构的时分,是如此脑洞大开,也 深深意识到了解一门技能的底层原理关于从事该方面工作的重要性。

因而咱们决议 进一步探求iOS底层原理的任务。在这篇文章中咱们环绕Block展开,会逐个探求:Block目标类型(实质)与内存布局、变量捕获、Block的品种、Block的润饰符、内存办理、循环引证

一、Block的根本语法和运用介绍

在探求Block的底层原理之前,咱们需求先回顾一下Block在日常开发中的运用和相关的语法。能够经过我之前发表的这篇文章进行温故知新:Block的根本语法和运用介绍

二、探求block的实质

1. 一个简略的Block

首要写一个简略的block,将其转换成C++伪代码,检查一下其内部结构:

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        int age = 10;
        void(^block)(int ,int) = ^(int a, int b){
            NSLog(@"this is block,a = %d,b = %d",a,b);
            NSLog(@"this is block,age = %d",age);
        };
        block(3,5);
    }
    return 0;
}

运用指令即将代码转化为c++检查其内部结构，与OC代码进行比较

xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m

上图中将c++中block的声明和界说别离与oc代码中相对应显示。
将c++中block的声明和调用别离取出来检查其内部完结。

1.1 界说block变量

// 界说block变量代码
void(*block)(int ,int) = ((void (*)(int, int))&__main_block_impl_0(
(void *)__main_block_func_0, 
&__main_block_desc_0_DATA, age)
);

• 一个函数:
  • 上述界说代码中，能够发现，block界说中调用了__main_block_impl_0函数
  • 而且将__main_block_impl_0函数的地址赋值给了block

那么咱们来看一下__main_block_impl_0函数内部结构。

1.2 __main_block_imp_0结构体

• 结构函数:
  • __main_block_imp_0结构体内有一个同名结构函数__main_block_imp_0
  • 结构函数中对一些变量进行了赋值终究会回来一个结构体

那么也便是说终究将一个__main_block_imp_0结构体的内存地址赋值给了block变量

• 结构函数的参数:
  • __main_block_impl_0结构函数中传入了四个参数:
    • (void *)__main_block_func_0
    • &__main_block_desc_0_DATA
    • age
    • flags
      • 其间flage有默许值，也就说flage参数在调用的时分能够省略不传。
      • 而最后的 age(_age)则表示传入的_age参数会主动赋值给age成员，相当于age = _age

接下来着重看一下前面三个参数别离代表什么。

1.2.1 第一个参数:(void *)__main_block_func_0

从代码中咱们能够看到:

• 在__main_block_func_0函数中首要取出block中age的值
• 紧接着能够看到两个了解的NSLog
• 咱们不难发现这两段代码恰恰是咱们在block块中写下的代码。
• 咱们不难得出定论：
  • __main_block_func_0函数中其实存储着咱们在block中写下的代码
  • 而__main_block_impl_0函数中传入的是(void *)__main_block_func_0
    • 也就说将咱们写在block块中的代码封装成__main_block_func_0函数
    • 并将__main_block_func_0函数的地址传入了__main_block_impl_0的结构函数中保存在结构体内

1.2.2 第二个参数: &__main_block_desc_0_DATA

从代码中咱们能够看到:

• __main_block_desc_0中存储着两个参数:reserved和Block_size
• 而且reserved默许赋值为0
• 而Block_size则存储着__main_block_impl_0的占用空间大小
• 终究将__main_block_desc_0结构体的地址传入__main_block_impl_0的结构函数中赋值给Desc

1.2.3 第三个参数:age

age是咱们前面界说的部分变量

咱们能够先敲一段代码做一个简略的测验

int age = 10;
void(^block)(int ,int) = ^(int a, int b){
     NSLog(@"this is block,a = %d,b = %d",a,b);
     NSLog(@"this is block,age = %d",age);
};
age = 20;
block(3,5); 
// log: this is block,a = 3,b = 5
//      this is block,age = 10

打印成果:

• 经过打印成果,咱们发现,在Block内部打印的age是在它被从头赋值之前,也便是Block界说之前的旧值10

值传递:

• 咱们前面将OC代码 经过 指令行编译 成C++之后的代码中咱们也能够看到,传如Block中的age是 值传递
  
• 且,经过前面的简略测验,咱们也不难得出定论:这儿Block捕获到的值,是在Block界说代码中,第一次编译之后就确认了
  地址传递:
• 而另外两个参数:(void *)__main_block_func_0、&__main_block_desc_0_DATA,都是地址传递
• 经过地址传递,在被调用时分,才有寻址操作

因而在block界说之后对部分变量进行改动是无法被block捕获的。

1.3 进一步检查__main_block_impl_0结构体

1.3.1 第一个成员:__block_impl结构体

首要咱们看一下__main_block_impl_0结构体的第一个成员变量__block_impl结构体：

经过代码咱们不难发现:

• isa指针:
  • __block_impl结构体内部就有一个isa指针
  • 因而能够证明 block实质上便是一个oc目标
  • 而经过结构函数初始化的__main_block_impl_0结构体实例的内存地址赋值给block变量
    • 经过block变量的指针指向的地址(也便是)__main_block_impl_0实例的地址,能够拿到 结构体中的 第一个成员 __block_impl的地址
    • 从而去获取内部的 isa指针、FuncPtr等进行操作

1.3.2 第二个成员:__main_block_desc_0结构体

咱们在前面 1.2.2 &__main_block_desc_0_DATA 中现已 探求过该结构体:

• __main_block_desc_0中存储着两个参数:reserved和Block_size
• 而且reserved默许赋值为0
• 而Block_size则存储着__main_block_impl_0的占用空间大小
• 终究将__main_block_desc_0结构体的地址传入__main_block_impl_0的结构函数中赋值给Desc

1.4 总结

经过前面的探求,咱们能够得出定论：

• 1. Block的实质:
  • __block_impl结构体中isa指针,咱们前面探求OC目标的实质,知道,每一个承继自NSObject的目标,都有isa指针
  • 因而Block实质上是一个OC目标
  • 咱们经过简略打印调试,能够看到此刻的Block的详细类型为_NSConcreteStackBlock类型
• 2. Block的履行函数:
  • block代码块中的代码被封装成__main_block_func_0函数
  • FuncPtr则存储着__main_block_func_0函数的地址。
• 3. 目标内存:
  • Desc指向__main_block_desc_0结构体目标，其间存储__main_block_impl_0结构体所占用的内存。

2.调用block履行内部代码

// 履行block内部的代码
((void (*)(__block_impl *, int, int))((__block_impl *)block)->FuncPtr)
                                      ((__block_impl *)block,
                                                         3, 
                                                        5);

结构体的指针:

• 经过上述代码能够发现调用block是经过block找到FunPtr直接调用
• 经过前面的剖析咱们知道block指向的是__main_block_impl_0类型结构体
• 可是咱们发现__main_block_impl_0结构体中并不能直接找到FunPtr(FunPtr是存储在__block_impl中的
• 那么为什么block能够直接调用__block_impl中的FunPtr呢？

  • 从头检查上述源代码能够发现:

    • 类型强转: (__block_impl *)block将block强制转化为__block_impl类型
    • 结构体的第一个成员: 又由于__block_impl是__main_block_impl_0结构体的第一个成员(结构体本身的内存地址,便是指向其内部第一个成员的地址。这是C言语中指针的常识)
    • 所以能够根据类型强转后拿到的内存地址,找到FunPtr成员并履行

  • 从前面的剖析咱们知道，FunPtr中存储着经过代码块封装的代码的函数地址，那么调用此函数，也便是会履行代码块中的代码。

  • 而且回头检查__main_block_func_0函数，能够发现第一个参数便是__main_block_impl_0类型的指针。也便是说将block传入__main_block_func_0函数中，便于重中取出block捕获的值。

3. 怎么验证block的实质的确是__main_block_impl_0结构体类型。

咱们能够经过手写与之相似的结构体代码,并在OC代码中,对Block进行类型强转。
从而经过调用类型强转之后的结构体目标,检查一下打印成果,看看是否能够跟以往OC代码中的Block相同调用代码块中,且给出相同的 打印成果

struct __main_block_desc_0 {
    size_t reserved;
    size_t Block_size;
};
struct __block_impl {
    void *isa;
    int Flags;
    int Reserved;
    void *FuncPtr;
};
// 仿照体系__main_block_impl_0结构体
struct __main_block_impl_0 { 
    struct __block_impl impl;
    struct __main_block_desc_0* Desc;
    int age;
};
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        int age = 10;
        void(^block)(int ,int) = ^(int a, int b){
            NSLog(@"this is block,a = %d,b = %d",a,b);
            NSLog(@"this is block,age = %d",age);
        };
// 将底层的结构体强制转化为咱们自己写的结构体，经过咱们自界说的结构体探寻block底层结构体
        struct __main_block_impl_0 *blockStruct = (__bridge struct __main_block_impl_0 *)block;
        block(3,5);
    }
    return 0;
}

经过代码证明：咱们将block内部的结构体强制转化为自界说的结构体，转化成功阐明底层结构体的确如咱们之前剖析成果的相同。

经过打断点能够看出咱们自界说的结构体能够被赋值成功，以及里边的值。

接下来断点来到block代码块中，看一下仓库信息中的函数调用地址。Debuf workflow -> always show Disassembly

经过上图能够看到地址的确和FuncPtr中的代码块地址相同。

4.总结

此刻现已根本对block的底层结构有了根本的知道，上述代码能够经过一张图展现其间各个结构体之间的联系。

• 各个结构体之间的联系
  
• block底层的数据结构
  • block底层的数据结构也能够经过一张图来展现:
    
• 对block有一个根本的知道:
  • block实质上也是一个oc目标，ta内部也有一个isa指针
  • block是封装了函数调用以及函数调用环境的OC目标(Block或许会读外部的值有捕获)

三、Block对变量的捕获

咱们在前面的篇幅中,得知Block对变量 或许存在 值捕获 的现象。那么咱们顺着这个思路进一步探求 Block对变量 捕获的原理

为了保证block内部能够正常拜访外部的变量，block有一个变量捕获机制。

1. 部分变量

1.1 auto变量

在OC中,部分变量的类型 实质上便是auto变量

咱们在前面的篇幅中现已了解过block对部分变量age的捕获

咱们得出了定论:

• auto主动变量，离开效果域就毁掉，通常部分变量前面主动增加auto关键字。
• 主动变量的值会被捕获到block内部，也便是说block内部会专门新增加一个参数来存储变量的值。
• 值传递: auto只存在于部分变量中，拜访办法为值传递，经过前面篇幅的探求咱们也能够确定对auto变量age的捕获 的确是值传递。

1.2 static变量

接下来别离增加aotu润饰的部分变量和static润饰的部分变量，重看源码来看一下他们之间的不同。

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        auto int a = 10;
        static int b = 11;
        void(^block)(void) = ^{
            NSLog(@"hello, a = %d, b = %d", a,b);
        };
        a = 1;
        b = 2;
        block();
    }
    return 0;
}
// log : block实质[57465:18555229] hello, a = 10, b = 2
// block中a的值没有被改动而b的值随外部改变而改变。

从头生成c++代码看一下内部结构中两个参数的区别:

从代码中咱们不难看出看出:

• a,b两个变量都有捕获到block内部
• 可是a传入的是值，而b传入的则是地址

为什么两种变量会有这种差异呢?

• 由于主动变量或许会毁掉，block在履行的时分有或许主动变量现已被毁掉了，那么此刻假如再去拜访被毁掉的地址肯定会发生坏内存拜访，因而关于主动变量一定是值传递而不或许是指针传递了。
• 而静态变量不会被毁掉，所以完全能够传递地址。而由于传递的是值得地址，所以在block调用之前修正地址中保存的值，block中的地址是不会变得。所以值会随之改动。

定论:

• 指针传递: static 润饰的变量为指针传递，相同会被block捕获。

2. 大局变量

咱们相同以代码的办法看一下block是否捕获大局变量

int a = 10;
static int b = 11;
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        void(^block)(void) = ^{
            NSLog(@"hello, a = %d, b = %d", a,b);
        };
        a = 1;
        b = 2;
        block();
    }
    return 0;
}
// log hello, a = 1, b = 2

相同生成c++代码检查大局变量调用办法:

经过上述代码能够发现，__main_block_imp_0并没有增加任何变量，因而block不需求捕获大局变量，由于大局变量不管在哪里都能够被拜访。

部分变量由于跨函数拜访所以需求捕获，大局变量在哪里都能够拜访 ，所以不必捕获。

3. 总结

• 部分变量: 都会被block捕获
  • 主动变量是值捕获
  • 静态变量为地址捕获
• 大局变量: 大局变量则不会被block捕获

4.疑问：以下代码中block是否会捕获变量呢？

#import "Person.h"
@implementation Person
- (void)test
{
    void(^block)(void) = ^{
        NSLog(@"%@",self);
    };
    block();
}
- (instancetype)initWithName:(NSString *)name
{
    if (self = [super init]) {
        self.name = name;
    }
    return self;
}
+ (void) test2
{
    NSLog(@"类办法test2");
}
@end

相同转化为c++代码检查其内部结构

从代码中,咱们不难发现:

• self相同被block捕获
• 接着咱们找到test办法能够发现，test办法默许传递了两个参数self和_cmd
• 而类办法test2也相同默许传递了类目标self和办法选择器_cmd
  

不论目标办法仍是类办法都会默许将self作为参数传递给办法内部，既然是作为参数传入，那么self肯定是部分变量。上面讲到部分变量肯定会被block捕获。

接着咱们来看一下假如在block中运用成员变量或许调用实例的特点会有什么不同的成果。

- (void)test
{
    void(^block)(void) = ^{
        NSLog(@"%@",self.name);
        NSLog(@"%@",_name);
    };
    block();
}

上图中能够发现，即使block中运用的是实例目标的特点，block中捕获的仍然是实例目标，并经过实例目标经过不同的办法去获取运用到的特点。

四、Block的品种

1. block的class

block目标是什么类型的?

在前面探求 block对auto变量age的时分,咱们经过调试得出了定论:block中的isa指针指向的是_NSConcreteStackBlock类目标地址。

那么block是否便是_NSConcreteStackBlock类型的呢？

咱们经过代码用class办法或许isa指针检查详细类型。

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // __NSGlobalBlock__ : __NSGlobalBlock : NSBlock : NSObject
        void (^block)(void) = ^{
            NSLog(@"Hello");
        };
        NSLog(@"%@", [block class]);
        NSLog(@"%@", [[block class] superclass]);
        NSLog(@"%@", [[[block class] superclass] superclass]);
        NSLog(@"%@", [[[[block class] superclass] superclass] superclass]);
    }
    return 0;
}

打印内容

从上述打印内容能够看出：

• block终究都是承继自NSBlock类型，而NSBlock承继于NSObjcet
• 那么block其间的isa指针其实是来自NSObject中的。咱们在这一步进一步验证了block的实质便是OC目标

2. 探求Block的类型

2.1 block的三品种型

咱们首要手写三个block：

• 不捕获变量的Block
• 捕获变量的Block
• 匿名Block
  经过代码检查一下block在什么状况下其类型会各不相同:

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // 1. 内部没有调用外部变量的block
        void (^block1)(void) = ^{
            NSLog(@"Hello");
        };
        // 2. 内部调用外部变量的block
        int a = 10;
        void (^block2)(void) = ^{
            NSLog(@"Hello - %d",a);
        };
       // 3. 直接调用的block的class
        NSLog(@"%@ %@ %@", [block1 class], [block2 class], [^{
            NSLog(@"%d",a);
        } class]);
    }
    return 0;
}

打印成果:

咱们不难发现呈现了三品种型的Block:

__NSGlobalBlock__ （ _NSConcreteGlobalBlock ）
__NSStackBlock__ （ _NSConcreteStackBlock ）
__NSMallocBlock__ （ _NSConcreteMallocBlock ）

• 但咱们将上述代码转化为c++代码检查源码时却发现block的类型与打印出来的类型不相同
  • c++源码中三个block的isa指针悉数都指向_NSConcreteStackBlock类型地址。
• 咱们能够猜想runtime运转时过程中也许对类型进行了转变
  • 终究类型当然以runtime运转时类型也便是咱们打印出的类型为准。

五、Block的内存办理

1. 了解程序的内存分区

• 1. 代码区 code
     • 程序被操作体系加载到内存时，一切可履行的代码被加载到代码区，也叫代码段
     • 程序运转这段时刻该区域数据不可被修正只能够被履行。
• 2. 静态区
  • 程序被加载到内存时就现已分配好，程序退出时才从内存中消失
  • 存储静态变量和大局变量。代码履行期间一向占用内存！
• 3. 栈区
  • 一种先进后出的存储结构，一切的主动变量（auto润饰的相当于部分变量）,函数的参数，函数的回来值都是栈区变量
  • 不需求用户请求开释，编译器主动完结。
• 4. 堆区 heap
  • 一个比较大的内存容器（比栈大），需求咱们手动的请求和开释内存。
  • 在C言语中,堆区内存的运用函数：头文件#include <stdlib.h>

    • 1：malloc 请求堆区内存。 void * malloc(size_t size);

      • size为请求的内存的字节数。请求的空间随机不会初始化， 所以不知道内部值是多少。

    • 2：free 开释请求的内存。 free(void *ptr);

      • 只能开释你请求的内存，否则就会犯错。

    • 3: calloc 请求堆区内存。 void *calloc(size_t nmemb, size_t size);

      • nmemb:指定单位的数量，size;单位的数量。
      • 比如：malloc(10*sizeof(int)); == calloc(10,sizeof(int));
        区别：malloc请求的内存不负责初始化，而calloc请求的内存现已初始化为0.

    • 4：realloc 能够扩展之前请求的内存 void *realloc(void *ptr, size_t size);

      • ptr 要扩充的区域地址，size 扩充之后的大小。

      • 比如：char *a=(char )malloc(10sizeof(char));//10个字节

      • realloc(a,100);//增加为100个字节，也不会初始化。

2 探求Block对其类型的详细界说

由于在ARC环境中,编译器会帮咱们办理内存,为了便于探求观察,咱们能够先封闭ARC回到MRC环境下

// MRC环境！！！
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // Global：没有拜访auto变量：__NSGlobalBlock__
        void (^block1)(void) = ^{
            NSLog(@"block1---------");
        };   
        // Stack：拜访了auto变量： __NSStackBlock__
        int a = 10;
        void (^block2)(void) = ^{
            NSLog(@"block2---------%d", a);
        };
        NSLog(@"%@ %@", [block1 class], [block2 class]);
        // __NSStackBlock__调用copy ： __NSMallocBlock__
        NSLog(@"%@", [[block2 copy] class]);
    }
    return 0;
}

检查打印内容

经过打印的成果咱们不难得知:

• __NSGlobalBlock__:
  • 没有拜访auto变量的block是__NSGlobalBlock__类型的，寄存在数据段中(代码区)
• __NSStackBlock__:
  • 拜访了auto变量的block是__NSStackBlock__类型的，寄存在栈中
• __NSMallocBlock__:
  • __NSStackBlock__类型的block调用copy成为__NSMallocBlock__类型并被仿制寄存在堆中
• ps:关于不同Block存在在那块内存区域,需求根据打印其目标地址 且打断点 结合 检查汇编 中呈现 的 不同 内存区域的 地址进行比对 做适量估测。此处的定论 参考 自 《Effective-ObjectiveC》一书

block是怎么界说其类型，依据什么来为block界说不同的类型并分配在不同的空间呢？首要看下面一张图

3. block在内存中的存储

经过下面一张图看一下不同block的寄存区域

上图中能够发现，根据block的类型不同，block寄存在不同的区域中。 数据段中的__NSGlobalBlock__直到程序完毕才会被收回，不过咱们很少运用到__NSGlobalBlock__类型的block，由于这样运用block并没有什么意义。

__NSStackBlock__类型的block寄存在栈中，咱们知道栈中的内存由体系主动分配和开释，效果域履行完毕之后就会被立即开释，而在相同的效果域中界说block而且调用block好像也多此一举。

__NSMallocBlock__是在平常编码过程中最常运用到的。寄存在堆中需求咱们自己进行内存办理。
上面提到过__NSGlobalBlock__类型的咱们很少运用到，由于假如不需求拜访外界的变量，直接经过函数完结就能够了，不需求运用block。

可是__NSStackBlock__拜访了aotu变量，而且是寄存在栈中的，上面提到过，栈中的代码在效果域完毕之后内存就会被毁掉，那么咱们很有或许block内存毁掉之后才去调用他，那样就会发生问题，经过下面代码能够证明这个问题。

void (^block)(void);
void test()
{
    // __NSStackBlock__
    int a = 10;
    block = ^{
        NSLog(@"block---------%d", a);
    };
}
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        test();
        block();
    }
    return 0;
}

此刻检查打印内容

能够发现a的值变为了不可控的一个数字。为什么会发生这种状况呢？

由于上述代码中创立的block是__NSStackBlock__类型的，因而block是存储在栈中的，那么当test函数履行完毕之后，栈内存中block所占用的内存现已被体系收回，因而原来的就有或许呈现。检查其c++代码能够更清楚的了解。

为了避免这种状况发生，能够经过copy将__NSStackBlock__类型的block转化为__NSMallocBlock__类型的block，将block存储在堆中，以下是修正后的代码。

void (^block)(void);
void test()
{
    // __NSStackBlock__ 调用copy 转化为__NSMallocBlock__
    int age = 10;
    block = [^{
        NSLog(@"block---------%d", age);
    } copy];
    [block release];
}

此刻在打印就会发现数据正确

那么其他类型的block调用copy会改动block类型吗？下面表格现已展现的很明晰了。

所以在平常开发过程中:

• MRC环境下常常需求运用copy来保存block，将栈上的block复制到堆中，即使栈上的block被毁掉，堆上的block也不会被毁掉，需求咱们自己调用release操作来毁掉
• 而在ARC环境下体系会主动调用copy操作，使block不会被毁掉

4.ARC帮咱们做了什么

在ARC环境下，编译器会根据状况主动将栈上的block进行一次copy操作，将block仿制到堆上。

什么状况下ARC会主动将block进行一次copy操作？ 以下代码都在RAC环境下履行。

1. block作为函数回来值时

typedef void (^Block)(void);
Block myblock()
{
    int a = 10;
    // 前面探求时提到过，block中拜访了auto变量，此刻block类型应为__NSStackBlock__
    Block block = ^{
        NSLog(@"---------%d", a);
    };
    return block;
}
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Block block = myblock();
        block();
       // 打印block类型为 __NSMallocBlock__
        NSLog(@"%@",[block class]);
    }
    return 0;
}

看一下打印的内容:

• 在前面篇幅探求过程中得出一个定论:在block中拜访了auto变量时，block的类型为__NSStackBlock__
• 上面打印成果却显示blcok为__NSMallocBlock__类型的，而且能够正常打印出a的值，阐明block内存并没有被毁掉
• 在前面篇幅探求过程中也得出一个定论: __NSStackBlock__类型的block 进行copy操作会转化为__NSMallocBlock__类型
• 那么阐明ARC环境中，当block作为函数回来值时会主动帮助咱们对block进行copy操作，并保存block的内存，并在恰当的当地进行release操作。

2. 将block赋值给__strong指针时

block被强指针引证时，ARC环境下 编译器也会主动对block进行一次copy操作。

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // block内没有拜访auto变量
        Block block = ^{
            NSLog(@"block---------");
        };
        NSLog(@"%@",[block class]);
        int a = 10;
        // block内拜访了auto变量，但没有赋值给__strong指针
        NSLog(@"%@",[^{
            NSLog(@"block1---------%d", a);
        } class]);
        // block赋值给__strong指针(经过一个类型来结构界说一个目标,默许是__strong指针)
        Block block2 = ^{
          NSLog(@"block2---------%d", a);
        };
        NSLog(@"%@",[block1 class]);
    }
    return 0;
}

检查打印内容能够看出，当block被赋值给__strong指针时，在ARC会环境下主动进行一次copy操作。

3. block作为Cocoa API中办法名含有usingBlock的办法参数时

例如：遍历数组的block办法，将block作为参数的时分。

NSArray *array = @[];
[array enumerateObjectsUsingBlock:^(id  _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
}];

4. block作为GCD API的办法参数时

例如：GDC的一次性函数或推迟履行的函数，履行完block操作之后体系才会对block进行release操作。

static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
});        
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
});

5.block声明写法

经过上面临MRC及ARC环境下block的不同类型的剖析，总结出不同环境下block特点主张写法。

MRC下block特点的主张写法

@property (copy, nonatomic) void (^block)(void);

ARC下block特点的主张写法

@property (strong, nonatomic) void (^block)(void); @property (copy, nonatomic) void (^block)(void);

六、Block的润饰符

1. __weak润饰

• 如下代码

// 界说block
typedef void (^HPBlock)(void);
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        HPBlock block;
        {
            HPPerson *person = [[HPPerson alloc]init];
            person.age = 10;
            __weak HPPerson *weakPerson = person;
            block = ^{
                NSLog(@"---------%d", weakPerson.age);
            };
             NSLog(@"block.class = %@",[block class]);
        }
        NSLog(@"block毁掉");
    }
    return 0;
}

• 输出为

iOS-block[3687:42147] block.class = __NSMallocBlock__
iOS-block[3687:42147] -[HPPerson dealloc]
iOS-block[3687:42147] block毁掉

咱们将代码转换成cpp伪代码检查下:

留意：

• 在运用clang转换OC为C++代码时，或许会遇到以下问题 cannot create __weak reference in file using manual reference
• 处理计划：支撑ARC、指定运转时体系版别，比方 xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc -fobjc-arc -fobjc-runtime=ios-8.0.0 main.m

生成之后，能够看到，如下代码，MRC状况下，生成的代码显着多了,这是由于ARC主动进行了copy操作

 //copy 函数
  void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*); 
  //dispose函数
  void (*dispose)(struct __main_block_impl_0*); 

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  //weak润饰
   HPPerson *__weak weakPerson;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, HPPerson *__weak _weakPerson, int flags=0) : weakPerson(_weakPerson) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
  //copy 函数
  void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*);
  //dispose函数
  void (*dispose)(struct __main_block_impl_0*);
} __main_block_desc_0_DATA = {
 0, 
 sizeof(struct __main_block_impl_0),
  __main_block_copy_0,
   __main_block_dispose_0
};
//copy函数内部会调用_Block_object_assign函数
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {
//asssgin会对目标进行强引证或许弱引证
_Block_object_assign((void*)&dst->person, 
(void*)src->person, 
3/*BLOCK_FIELD_IS_OBJECT*/);
}
//dispose函数内部会调用_Block_object_dispose函数
static void __main_block_dispose_0(struct __main_block_impl_0*src) {
_Block_object_dispose((void*)src->person, 
3/*BLOCK_FIELD_IS_OBJECT*/);
}

1.1 小结

不管是MRC仍是ARC
当block内部拜访了目标类型的auto变量时:

• 假如block在栈上（即当block为__NSStackBlock__类型时分），将不会auto变量进行强引证
• 假如block被复制在堆上(即当block为__NSMallocBlock__类型时分）
  • 会调用block内部的copy函数
  • copy函数内部会调用_Block_object_assign函数
  • _Block_object_assign函数会根据auto变量的润饰符是__strong、__weak、__unsafe_unretained做出相应的操作,构成强引证(retain)或许弱引证。
• 假如block从堆上移除
  • 会调用block内部的dispose函数
  • dispose函数内部会调用_Block_object_dispose函数
  • _Block_object_dispose函数会主动开释引证的auto变量（release）
    其实也很好了解，由于block本身就在栈上，自己都随时或许消失，怎么能保住他人的命呢？

函数	调用机遇
copy函数	栈上的Block仿制到堆上
dispose函数	堆上的block被废弃时

2.__block润饰符

先从一个简略的比如说起，请看下面的代码

// 界说block
typedef void (^HPBlock)(void);
int age = 10;
HPBlock block = ^{
    NSLog(@"age = %d", age);
};
block();

代码很简略，运转之后，输出

age = 10

上面的比如在block中拜访外部部分变量，那么问题来了，假如想在block内修正外部部分的值，怎么做呢？

2.1 修正部分变量的三种办法

2.1.1 写成大局变量

咱们把a界说为大局变量，那么在哪里都能够拜访，

// 界说block
typedef void (^YZBlock)(void);
 int age = 10;
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        YZBlock block = ^{
            age = 20;
            NSLog(@"block内部修正之后age = %d", age);
        };
        block();
        NSLog(@"block调用完 age = %d", age);
    }
    return 0;
}

这个很简略，输出成果为

block内部修正之后age = 20
block调用完 age = 20

关于输出就成果也没什么问题，由于大局变量，是一切当地都可拜访的，在block内部能够直接操作age的内存地址的。调用完block之后，大局变量age指向的地址的值现已被更改为20，所以是上面的打印成果

2.1.2 static修正部分变量

// 界说block
typedef void (^HPBlock)(void);
int main(int argc, const char * argv[]) {
    @autoreleasepool {
       static int age = 10;
        HPBlock block = ^{
            age = 20;
            NSLog(@"block内部修正之后age = %d", age);
        }; 
        block();
        NSLog(@"block调用完 age = %d", age);
    }
    return 0;
} 

上面的代码输出成果为

block内部修正之后age = 20
block调用完 age = 20

终端履行这行指令xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m把main.m生成main.cpp 能够 看到如下代码

struct __main_block_impl_0 {
    struct __block_impl impl;
    struct __main_block_desc_0* Desc;
    int *age;
    __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int *_age, int flags=0) : age(_age) {
        impl.isa = &_NSConcreteStackBlock;
        impl.Flags = flags;
        impl.FuncPtr = fp;
        Desc = desc;
    }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
    int *age = __cself->age; // bound by copy
    (*age) = 20;
    NSLog((NSString *)&__NSConstantStringImpl__var_folders_x4_920c4yq936b63mvtj4wmb32m0000gn_T_main_5dbaa1_mi_0, (*age));
}

能够看出，当部分变量用static润饰之后，这个block内部会有个成员是int *age，也便是说把age的地址捕获了。这样的话，当然在block内部能够修正部分变量age了。

• 以上两种办法，尽管能够到达在block内部修正部分变量的意图，可是，这样做，会导致内存无法开释。
  • 不管是大局变量，仍是用static润饰，都无法及时毁掉，会一向存在内存中。
  • 很多时分，咱们只是需求临时用一下，当不必的时分，能毁掉掉，那么第三种，也便是今日的主角 __block

2.2 __block来润饰

代码如下

// 界说block
typedef void (^HPBlock)(void); 
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        __block int age = 10;
        HPBlock block = ^{
            age = 20;
            NSLog(@"block内部修正之后age = %d",age);
        };
        block();
        NSLog(@"block调用完 age = %d",age);
    }
    return 0;
} 

输出成果和上面两种相同

block内部修正之后age = 20
block调用完 age = 20

2.2.1 __block剖析

• 终端履行这行指令xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m把main.m生成main.cpp

首要能发现 多了__Block_byref_age_0结构体

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
    // 这儿多了__Block_byref_age_0类型的结构体
  __Block_byref_age_0 *age; // by ref
    // fp是函数地址  desc是描述信息  __Block_byref_age_0 类型的结构体  *_age  flags标记
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_age_0 *_age, int flags=0) : age(_age->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp; //fp是函数地址
    Desc = desc;
  }
};

再仔细看结构体__Block_byref_age_0，能够发现第一个成员变量是isa指针，第二个是指向本身的指针__forwarding

// 结构体 __Block_byref_age_0
struct __Block_byref_age_0 {
    void *__isa; //isa指针
    __Block_byref_age_0 *__forwarding; // 指向本身的指针
    int __flags;
    int __size;
    int age; //运用值
};

检查main函数里边的代码

  // 这是原始的代码 __Block_byref_age_0
 __attribute__((__blocks__(byref))) __Block_byref_age_0 age = {
 (void*)0,(__Block_byref_age_0 *)&age, 0, sizeof(__Block_byref_age_0), 10};
// 这是原始的 block代码
HPBlock block = ((void (*)())&__main_block_impl_0(
(void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_age_0 *)&age, 570425344));

代码太长，简化一下，去掉一些强转的代码，成果如下

// 这是原始的代码 __Block_byref_age_0
__attribute__((__blocks__(byref))) __Block_byref_age_0 age = {(void*)0,(__Block_byref_age_0 *)&age, 0, sizeof(__Block_byref_age_0), 10};
//这是简化之后的代码 __Block_byref_age_0
__Block_byref_age_0 age = {
     0, //赋值给 __isa
     (__Block_byref_age_0 *)&age,//赋值给 __forwarding,也便是本身的指针
      0, // 赋值给__flags
      sizeof(__Block_byref_age_0),//赋值给 __size
      10 // age 运用值
    };
// 这是原始的 block代码
HPBlock block = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_age_0 *)&age, 570425344));
// 这是简化之后的 block代码
HPBlock block = (&__main_block_impl_0(
             		__main_block_func_0,
           		&__main_block_desc_0_DATA,
	           	 &age,
            	570425344));
 ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
        //简化为
block->FuncPtr(block);

其间__Block_byref_age_0结构体中的第二个(__Block_byref_age_0 *)&age赋值给上面代码结构体__Block_byref_age_0中的第二个__Block_byref_age_0 *__forwarding,所以__forwarding 里边寄存的是指向本身的指针

//这是简化之后的代码 __Block_byref_age_0
__Block_byref_age_0 age = {
     0, //赋值给 __isa
     (__Block_byref_age_0 *)&age,//赋值给 __forwarding,也便是本身的指针
      0, // 赋值给__flags
      sizeof(__Block_byref_age_0),//赋值给 __size
      10 // age 运用值
    };

结构体__Block_byref_age_0中代码如下，第二个__forwarding寄存指向本身的指针,第五个age里边寄存部分变量

// 结构体 __Block_byref_age_0
struct __Block_byref_age_0 {
    void *__isa; //isa指针
    __Block_byref_age_0 *__forwarding; // 指向本身的指针
    int __flags;
    int __size;
    int age; //运用值
};

调用的时分，先经过__forwarding找到指针，然后去取出age值。

(age->__forwarding->age));

2.2.2 __block的内存办理

• 当block在栈上时，并不会对__block变量发生强引证
• 当block被copy到堆时
  • 会调用block内部的copy函数
  • copy函数内部会调用_Block_object_assign函数
  • _Block_object_assign函数会根据所指向目标的润饰符（__strong、__weak、__unsafe_unretained）做出相应的操作，构成强引证（retain）或许弱引证（留意：这儿仅限于ARC时会retain，MRC时不会retain）

• 当block从堆中移除时
  • 会调用block内部的dispose函数
  • dispose函数内部会调用_Block_object_dispose函数
  • _Block_object_dispose函数会主动开释引证的__block变量（release）

2.2.3 __block的__forwarding指针

结构体__Block_byref_obj_0

//结构体__Block_byref_obj_0中有__forwarding
 struct __Block_byref_obj_0 {
  		void *__isa;
		__Block_byref_obj_0 *__forwarding;
		 int __flags;
 		int __size;
 		void (*__Block_byref_id_object_copy)(void*, void*);
 		void (*__Block_byref_id_object_dispose)(void*);
 		NSObject *__strong obj;
};
// 拜访的时分
age->__forwarding->age

为啥什么不直接用age,而是age->__forwarding->age呢？

这是由于:

• 假如__block变量在栈上，就能够直接拜访
• 可是假如现已复制到了堆上，拜访的时分，还去拜访栈上的，就会出问题，所以，先根据__forwarding找到堆上的地址，然后再取值

2.2.4 小结

• __block能够用于处理block内部无法修正auto变量值的问题
• __block不能润饰大局变量、静态变量（static）
• 编译器会将__block变量包装成一个目标
• 调用的是，从__Block_byref_age_0的指针找到 age地点的内存，然后修正值

七、运用Block时的循环引证问题

继续探求一下block的循环引证问题。

看如下代码，有个Person类，里边两个特点，别离是block和age

#import <Foundation/Foundation.h>
typedef void (^HPBlock) (void);
@interface HPPerson : NSObject
@property (copy, nonatomic) HPBlock block;
@property (assign, nonatomic) int age;
@end
#import "HPPerson.h"
@implementation HPPerson
- (void)dealloc
{
    NSLog(@"%s", __func__);
}
@end

main.m中如下代码

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        HPPerson *person = [[HPPerson alloc] init];
        person.age = 10;
        person.block = ^{
             NSLog(@"person.age--- %d",person.age);
        };
        NSLog(@"--------");
    }
    return 0;
}

输出只要

iOS-block[38362:358749] ——–

也便是说程序完毕，person都没有开释，造成了内存走漏。

1. 循环引证原因

下面这行代码，是有个person指针，HPPerson

HPPerson *person = [[HPPerson alloc] init];

履行完

 person.block = ^{
             NSLog(@"person.age--- %d",person.age);
 };

之后，block内部有个强指针指向person，下面代码生成cpp文件

xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc -fobjc-arc -fobjc-runtime=ios-8.0.0 main.m

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
    //强指针指向person
  HPPerson *__strong person;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, HPPerson *__strong _person, int flags=0) : person(_person) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

而block是person的特点

@property (copy, nonatomic) HPBlock block;

当程序退出的时分，部分变量person毁掉，可是由于HPPerson和block直接，互相强引证，谁都开释不了。

2.__weak处理循环引证

为了处理上面的问题，只需求用__weak来润饰，即可

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        HPPerson *person = [[HPPerson alloc] init];
        person.age = 10;
        __weak HPPerson *weakPerson = person;
        person.block = ^{
            NSLog(@"person.age--- %d",weakPerson.age);
        };
        NSLog(@"--------");
    }
    return 0;
}

编译完结之后是

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
    // block内部对weakPerson是弱引证
  HPPerson *__weak weakPerson;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, HPPerson *__weak _weakPerson, int flags=0) : weakPerson(_weakPerson) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

当部分变量消失时分，关于HPPerson来说，只要一个弱指针指向它，那它就毁掉，然后block也毁掉。

3.__unsafe_unretained处理循环引证

除了上面的__weak之后，也能够用__unsafe_unretained来处理循环引证

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        HPPerson *person = [[HPPerson alloc] init];
        person.age = 10;
        __unsafe_unretained HPPerson *weakPerson = person;
        person.block = ^{
            NSLog(@"person.age--- %d",weakPerson.age);
        };
        NSLog(@"--------");
    }
    return 0;
}

关于的cpp文件为

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  HPPerson *__unsafe_unretained weakPerson;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, HPPerson *__unsafe_unretained _weakPerson, int flags=0) : weakPerson(_weakPerson) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

尽管__unsafe_unretained能够处理循环引证，可是最好不要用，由于:

• __weak：不会发生强引证，指向的目标毁掉时，会主动让指针置为nil
• __unsafe_unretained：不会发生强引证，不安全，指向的目标毁掉时，指针存储的地址值不变

4. __block处理循环引证

eg:

int main(int argc, const char * argv[]) {
    @autoreleasepool {
       __block HPPerson *person = [[HPPerson alloc] init];
        person.age = 10;
        person.block = ^{
            NSLog(@"person.age--- %d",person.age);
            //这一句不能少
            person = nil;
        };
        // 有必要调用一次
        person.block();
        NSLog(@"--------");
    }
    return 0;
}

上面的代码中，也是能够处理循环引证的。可是需求留意的是，person.block();有必要调用一次，为了履行person = nil;.

对应的成果如下

• 下面的代码，block会对__block发生强引证

__block HPPerson *person = [[HPPerson alloc] init];
person.block = ^{
        NSLog(@"person.age--- %d",person.age);
        //这一句不能少
        person = nil;
};

• person目标本身就对block是强引证

@property (copy, nonatomic) HPBlock block;

• __block对person发生强引证

struct __Block_byref_person_0 {
  void *__isa;
__Block_byref_person_0 *__forwarding;
 int __flags;
 int __size;
 void (*__Block_byref_id_object_copy)(void*, void*);
 void (*__Block_byref_id_object_dispose)(void*);
    //`__block`对person发生强引证
 HPPerson *__strong person;
};

所以他们的引证联系如图

当履行完person = nil时分,__block免除对person的引证,从而，全都免除开释了。 可是有必要调用person = nil才能够，否则，不能免除循环引证

5.小结

经过前面的剖析，咱们知道，ARC下，上面三种办法对比，最好的是__weak

6.MRC下留意点

假如再MRC下，由于不支撑弱指针__weak，所以，只能是__unsafe_unretained或许__block来处理循环引证

八、一些相关的面试题

做完前面的探求,咱们能够经过一些面试题来检验对常识点的掌握程度

1. block的原理是怎样的？实质是什么？
2. __block的效果是什么？有什么运用留意点？
3. block的特点润饰词为什么是copy？运用block有哪些运用留意？
4. block在修正NSMutableArray，需不需求增加__block？

专题系列文章

1.前常识

• 01-探求iOS底层原理|总述
• 02-探求iOS底层原理|编译器LLVM项目【Clang、SwiftC、优化器、LLVM】
• 03-探求iOS底层原理|LLDB
• 04-探求iOS底层原理|ARM64汇编

2. 基于OC言语探求iOS底层原理

• 05-探求iOS底层原理|OC的实质
• 06-探求iOS底层原理|OC目标的实质
• 07-探求iOS底层原理|几种OC目标【实例目标、类目标、元类】、目标的isa指针、superclass、目标的办法调用、Class的底层实质
• 08-探求iOS底层原理|Category底层结构、App启动时Class与Category装载过程、load 和 initialize 履行、相关目标
• 09-探求iOS底层原理|KVO
• 10-探求iOS底层原理|KVC
• 11-探求iOS底层原理|探求Block的实质|【Block的数据类型(实质)与内存布局、变量捕获、Block的品种、内存办理、Block的润饰符、循环引证】
• 12-探求iOS底层原理|Runtime1【isa详解、class的结构、办法缓存cache_t】
• 13-探求iOS底层原理|Runtime2【消息处理(发送、转发)&&动态办法解析、super的实质】
• 14-探求iOS底层原理|Runtime3【Runtime的相关使用】
• 15-探求iOS底层原理|RunLoop【两种RunloopMode、RunLoopMode中的Source0、Source1、Timer、Observer】
• 16-探求iOS底层原理|RunLoop的使用
• 17-探求iOS底层原理|多线程技能的底层原理【GCD源码剖析1:主行列、串行行列&&并行行列、大局并发行列】
• 18-探求iOS底层原理|多线程技能【GCD源码剖析1:dispatch_get_global_queue与dispatch_(a)sync、单例、线程死锁】
• 19-探求iOS底层原理|多线程技能【GCD源码剖析2:栅栏函数dispatch_barrier_(a)sync、信号量dispatch_semaphore】
• 20-探求iOS底层原理|多线程技能【GCD源码剖析3:线程调度组dispatch_group、事件源dispatch Source】
• 21-探求iOS底层原理|多线程技能【线程锁：自旋锁、互斥锁、递归锁】
• 22-探求iOS底层原理|多线程技能【原子锁atomic、gcd Timer、NSTimer、CADisplayLink】
• 23-探求iOS底层原理|内存办理【Mach-O文件、Tagged Pointer、目标的内存办理、copy、引证计数、weak指针、autorelease

3. 基于Swift言语探求iOS底层原理

关于函数、枚举、可选项、结构体、类、闭包、特点、办法、swift多态原理、String、Array、Dictionary、引证计数、MetaData等Swift根本语法和相关的底层原理文章有如下几篇:

• Swift5中心语法1-根底语法
• Swift5中心语法2-面向目标语法1
• Swift5中心语法2-面向目标语法2
• Swift5常用中心语法3-其它常用语法
• Swift5使用实践常用技能点

其它底层原理专题

1.底层原理相关专题

• 01-计算机原理|计算机图形烘托原理这篇文章
• 02-计算机原理|移动终端屏幕成像与卡顿 

2.iOS相关专题

• 01-iOS底层原理|iOS的各个烘托结构以及iOS图层烘托原理
• 02-iOS底层原理|iOS动画烘托原理
• 03-iOS底层原理|iOS OffScreen Rendering 离屏烘托原理
• 04-iOS底层原理|因CPU、GPU资源耗费导致卡顿的原因和处理计划

3.webApp相关专题

• 01-Web和类RN大前端的烘托原理

4.跨平台开发计划相关专题

• 01-Flutter页面烘托原理

5.阶段性总结:Native、WebApp、跨平台开发三种计划功能比较

• 01-Native、WebApp、跨平台开发三种计划功能比较

6.Android、HarmonyOS页面烘托专题

• 01-Android页面烘托原理
• 02-HarmonyOS页面烘托原理 (待输出)

7.小程序页面烘托专题

• 01-小程序结构烘托原理