欢迎关注
最酷最in的云资讯

重新回味·Block·

1713024-f0fff703edb00584.png说起Block,我想大家再熟悉不过了。每天的开发过程中都在与他打着交道,简洁高效的使用给我们的工作带来了便利。

正是因为Block对于我们而言不可或缺,我更觉得应该抽出时间好好认识一下Block,了解一些他的优缺点、过往经历,让我们对它的理解更深一层,进而开发出更加高效的程序。

对Block的认识

Block与C函数的区别和联系

Block是C语言的扩充,常被称为带有局部变量的匿名函数;

看一下正规的C语言函数定义:

int test(int count);int result = test(10);

以上声明了函数名为test函数;

使用函数指针调用函数:

int (*testFuncPtr)(int) = &test;int result = (* testFuncPtr)(10);

对比Block,Block就可以定义为不带名称的函数,说的直白一点,就是匿名函数,即不用显式的定义函数名称,但是匿名函数都有固定的一个表达式。

比如:

^(int count){  printf("%d", count);}等价于:void test(int count){}

Block语法定义格式如下:

^ 返回值类型 参数列表 表达式省略之后:^ 表达式

通过上面的例子可以看出两点不同:

  • 没有函数名称;

  • 带有“^”符号;

Block的基本使用

可以通过定义Block类型的变量对Block进行调用,与函数指针有相似之处,具体如下:

int (^block)(int) = ^(int count){      return count + 1;}block(5);

image.png

Block与Block的变量

Block类型变量用途:局部变量、参数、静态变量、全局变量以及静态全局变量等等。

Block 可以作为参数进行传递,也可以作为返回值进行传递,具体如下:

- (void)testFuncWithBlock:(void (^)(int count))block{    if (block) {        block(5);    }}// 将Block作为返回值,代码摘自·Masonry·- (MASConstraint * (^)(id))equalTo {    return ^id(id attribute) {        return self.equalToWithRelation(attribute, NSLayoutRelationEqual);    };}

具体以Masonry使用为例讲解一下,Block调用:

// Masonry 在常用布局时用到方法如下:make.top.equalTo(self.titleLabel.mas_bottom).offset(15);// 有些同学可能对上述的链式调用不是很清楚,其实上述链式调用就是使用Block实现的,分解如下:MASConstraint *constraint = make.top;MASConstraint *(^equalBlk)(id) = constraint.equalTo;constraint = equalBlk(self.titleLabel.mas_bottom);MASConstraint *(^offsetBlk)(CGFloat) = constraint.offset;constraint = offsetBlk(15);

可使用关键字typedef,进行Block类型变量的定义

typedef int(^Blk)(int);// 调用Blk blk = ^int (int count){        return count ++;    };    int result = blk(5);

Block 作为属性变量的用法:

@property (nonatomic, copy) void (^successCompletion)(int);@property (nonatomic, copy) Blk failCompletion;

通过上面一小节了解到:

  • 函数与Block区别与联系;

  • Block变量和Block表达式的联系

Block的实质

在前面小节中,介绍了Block的基本用法。那么问题来了,Block究竟是什么呢?现在公认的说法是带有自动变量的匿名函数,动手一探究竟。

使用Clang -rewrite-objc命令对下面代码进行编译:

void testBlock(){        int (^blk)(int) = ^(int count){        return count ++;    };    blk(5);}

执行完命令会在同级目录下生成XX.cpp文件,这个文件就是编译好的文件。

由于编译后文件包含很多C函数声明,在此就不一一解释了,主要关注上述Block方法实现:

struct __block_impl {  void *isa;  int Flags;  int Reserved;  void *FuncPtr;};static struct __testBlock_block_desc_0 {    size_t reserved;    size_t Block_size;} __testBlock_block_desc_0_DATA = { 0, sizeof(struct __testBlock_block_impl_0)};struct __testBlock_block_impl_0 {    struct __block_impl impl;    struct __testBlock_block_desc_0* Desc;        __testBlock_block_impl_0(void *fp, struct __testBlock_block_desc_0 *desc, int flags=0) {        impl.isa = &_NSConcreteStackBlock;        impl.Flags = flags;        impl.FuncPtr = fp;�        Desc = desc;    }};static int __testBlock_block_func_0(struct __testBlock_block_impl_0 *__cself, int count) {        return count ++;}

函数具体的实现如下:

void testBlock(){        int (*blk)(int) = ((int (*)(int))&__testBlock_block_impl_0((void *)__testBlock_block_func_0, &__testBlock_block_desc_0_DATA));    ((int (*)(__block_impl *, int))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk, 5);}

虽然编译后Block方法很长,但是并不复杂,Block调用就像普通的C函数的使用。

  • 首先,看一下源代码中Block方法体实现:

int (^blk)(int) = ^(int count){        return count ++;    };
static int __testBlock_block_func_0(struct __testBlock_block_impl_0 *__cself, int count) {        return count ++;}

可以发现两者在语法格式上非常相近,实际上Block所使用的匿名函数就是被作为简单的C函数处理的。

在代码中:

__testBlock_block_impl_0 *__cself

其中,参数__cself相当于C++中指向实例自身变量的this或者Objective-C中的self。参数__cself在这里是__testBlock_block_impl_0结构体的指针。

然后,看一下__testBlock_block_impl_0结构体的组成:

struct __testBlock_block_impl_0 {         struct __block_impl impl;         struct __testBlock_block_desc_0* Desc;};

去掉代码中加入的构造函数,感觉结构上清晰多了。第一个成员变量是impl,__block_impl结构体的声明如下所示:

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

其中,有关对象isa指针的理解可以参考之前写过的文章Objective-C Runtime:深入理解类与对象

第二个成员变量Desc,主要保存block所在内存的区域以及Block的大小。

  • 关于__testBlock_block_impl_0结构体构造函数如下:

__testBlock_block_impl_0(void *fp, struct __testBlock_block_desc_0 *desc, int flags=0) {        impl.isa = &_NSConcreteStackBlock;        impl.Flags = flags;        impl.FuncPtr = fp;�        Desc = desc;    }

isa指针指向_NSConcreteStackBlock, __testBlock_block_impl_0结构体相当于objc_object结构体的Objective-C类对象的结构体。

isa = &_NSConcreteStackBlock;

上述代码表明_NSConcreteStackBlock相当于objc_class结构体的实例。从而得知,Block就是Objective-C的对象了。

具体关于Objective-C类与对象的知识可以参考另一篇文章深入理解类与对象。

对于上述构造函数调用部分如下:

int (*blk)(int) = ((int (*)(int))&__testBlock_block_impl_0((void *)__testBlock_block_func_0, &__testBlock_block_desc_0_DATA));    ((int (*)(__block_impl *, int))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk, 5);

看着有些繁琐,对其去掉相关转换的部分:

struct __testBlock_block_impl_0 temp = __testBlock_block_impl_0(__testBlock_block_func_0, &__testBlock_block_desc_0_DATA);struct __testBlock_block_impl_0 *blk = & temp;(*blk->impl.FuncPtr)(blk, 5);

上述代码中,将__testBlock_block_impl_0结构体实例的指针赋值给变量blk,从而知道源代码中的Block表达式就是__testBlock_block_impl_0结构体类型的变量,同时也是该结构体在栈上生成的实例。

从函数指针调用得知,由Block语法转换的__testBlock_block_func_0函数指针被赋值到__testBlock_block_impl_0的成员变量FuncPtr,同时说明了__testBlock_block_func_0中的__cself指向Block值。

截获局部变量

在开发过程中,我们经常遇到在Block中截获局部变量或者改变局部变量,如下所示:

- (void)testBlock{        int value = 1;    void (^block) (void) = ^{        NSLog(@"value = %d", value);    };    block();}

看到这里,可能就有疑问了,Block内部是如何获取局部变量的,带着疑问重新Clang了一下源文件,似乎找到了答案,摘取了关键代码如下所示:

static void _I_TestBlock_testBlock(TestBlock * self, SEL _cmd) {    int value = 1;    void (*block) (void) = ((void (*)())&__TestBlock__testBlock_block_impl_0((void *)__TestBlock__testBlock_block_func_0, &__TestBlock__testBlock_block_desc_0_DATA, value));    ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);    }//Block内部实现:static void __TestBlock__testBlock_block_func_0(struct __TestBlock__testBlock_block_impl_0 *__cself) {  int value = __cself->value; // bound by copy  NSLog((NSString *)&__NSConstantStringImpl__var_folders_pf_nyb_8kl12yq6v2sxzwdr5v8w0000gn_T_TestBlock_516a43_mi_0, value);}// Block结构体struct __TestBlock__testBlock_block_impl_0 {  struct __block_impl impl;  struct __TestBlock__testBlock_block_desc_0* Desc; // 将局部变量追加成成员变量  int value;   __TestBlock__testBlock_block_impl_0(void *fp, struct __TestBlock__testBlock_block_desc_0 *desc, int _value, int flags=0) : value(_value) {    impl.isa = &_NSConcreteStackBlock;    impl.Flags = flags;    impl.FuncPtr = fp;    Desc = desc;  }};

通过上述Block语法表达式中使用的局部变量作为成员变量被加到了__TestBlock__testBlock_block_impl_0结构体中,同时,加到结构体中的成员变量的类型与局部变量的类型保持一致。当然了,如果Block表达式中没有使用局部变量,则不会加入到Block的结构体中。

通过初始化Block实例的构造方法和调用也可以看到局部变量value作为参数传递,具体如下所示:

//Block 初始化方法  __testBlock_block_impl_0(void *fp, struct __testBlock_block_desc_0 *desc, int _value, int flags=0) : value(_value)// 初始化方法的调用:void (*block) (void) = ((void (*)())&__testBlock_block_impl_0((void *)__testBlock_block_func_0, &__testBlock_block_desc_0_DATA, value));

到这里,大致明白了Block如何截获局部变量value的,小结如下:

  • 1、系统编译时,根据Block是否需要截获外部变量来判断是都将局部变量作为成员变量保存到Block的结构体__testBlock_block_impl_0中;

  • 2、若需要截获局部变量,需要在初始化结构体函数中添加与局部变量相同类型的参数;

  • 3、局部变量就通过初始化构造函数传递到Block结构体__testBlock_block_impl_0,同时赋值给Block中的成员变量;

  • 4、在执行Block时,局部变量value会初始化__testBlock_block_impl_0结构体实例, 如下所示;

    impl.isa = &_NSConcreteStackBlock;    impl.Flags = 0;    impl.FuncPtr = __testBlock_block_func_0;    Desc = &__testBlock_block_desc_0_DATA;    value = 1;

总的来说,截获局部变量就是将要使用的局部变量保存到Block结构体实例中。

Block中使用C语言数组

  • 只使用C语言的字符串数组,也没有向捕获的局部变量赋值,然而下面的代码再编译时就会产生错误,如下所示:

int testBlock1(){        const char country[] = "China";    void (^block) (void) = ^{        printf("text=%c",  country[1]);    };    block();        return 0;}

编译的时候会出现错误:

1713024-df9a9a88bffdca6e.png错误信息

看到这,你会感到疑惑,上面刚讲到Block是如何截获局部变量的,为什么到这里就失效了呢?

这是因为,Block中,没有实现对C语言数组的截获。通过上述截获局部变量的理论,C语言数组会作为成员变量保存到Block实例的结构体中,在初始化Block时,由成员变量赋值给局部变量,猜测代码如下:

void func(char a[]){    char b[] = a;}

从而看出端倪,将C语言数组类型变量赋值给C语言数据类型变量,这个在C语言下是无法编译,C语言不允许这样编译的。

如何解决呢?

目前,可以改成C语言数组的形式就可以解决上述问题了。

int testBlock1(){        const char *country = "China";    void (^block) (void) = ^{        printf("text=%c", country[1]);    };    block();        return 0;}

__block关键字的作用

前面的小节中,我们仅仅讲解了在Block中截获局部变量,那么,在Block中修改截获的局部变量又会带来什么样的问题呢?

image.png

修改截获的局部变量

通过上面的代码可以看出,虽然在Block中不能对局部变量进行修改,但是在全局变量、静态全局变量、静态变量都是可以在Block中进行修改的,具体如下:

int globalValue = 10;static int staticGlobalValue = 5;- (void)testBlockFunc {    static int value = 5;    void (^block)(void) = ^{                globalValue = 11;        staticGlobalValue = 12;        value = 3;        printf("globalValue = %d \n staticGlobalValue = %d \n value = %d \n", globalValue, staticGlobalValue, value);    };        block();}

打印的结果如下:

2018-12-02 21:56:47.323727+0800 TestBlock[38880:1182883] globalValue = 11 staticGlobalValue = 12 value = 3

再次使用clang编译了一下,发现静态全局变量和全局变量转换前后没有任何变换,大家可能疑问静态局部变量是如何转换的呢?

__TestBlockMemory__testBlockFunc_block_impl_0 *__cself) {      int *value = __cself->value; // bound by copy        globalValue = 11;        staticGlobalValue = 12;        (*value) = 3;        printf("globalValue = %d \n staticGlobalValue = %d \n value = %d \n", globalValue, staticGlobalValue, (*value));    }

与截获局部变量的转换很相似,唯一的区别是Int类型的变量转换成了指针,从而正确的改变了原有的值。

除了上述的几种方式可以在Block中修改变量值外,OC专门提供了一个说明符——__block。

int testBlock(){    __block int number = 1;    void (^block) (void) = ^{        number = 2;    };    block();    return 0;}

将上述代码进行Clang编译,还原成以下代码:

struct __Block_byref_number_0 {  void *__isa;__Block_byref_number_0 *__forwarding; int __flags; int __size; int number;};struct __testBlock_block_impl_0 {  struct __block_impl impl;  struct __testBlock_block_desc_0* Desc;  __Block_byref_number_0 *number; // by ref      __testBlock_block_impl_0(void *fp, struct __testBlock_block_desc_0 *desc, __Block_byref_number_0 *_number, int flags=0) : number(_number->__forwarding) {    impl.isa = &_NSConcreteStackBlock;    impl.Flags = flags;    impl.FuncPtr = fp;    Desc = desc;  }};static void __testBlock_block_func_0(struct __testBlock_block_impl_0 *__cself) {  __Block_byref_number_0 *number = __cself->number; // bound by ref                (number->__forwarding->number) = 2;}

惊奇的发现,局部变量number变成了结构体__Block_byref_number_0,Block的__testBlock_block_impl_0的结构体实例持有__block变量的__Block_byref_number_0结构体实例的指针。__testBlock_block_impl_0实例的成员变量__forwarding指向实例自身,并通过__forwarding变量访问成员变量** number**。

__Block_byref_number_0 *number = __cself->number; // bound by ref (number->__forwarding->number) = 2;

值得注意一点是,__Block_byref_number_0结构体并没有在__testBlock_block_impl_0结构体中,这样主要是为了在多个Block中共用该__block变量。

Block的储存

Block分为三类:** _NSConcreteStackBlock**

种类 存储域 Block变量类型 复制后的存储域
_NSConcreteStackBlock 局部/自动变量 由栈复制到堆上
_NSConcreteGlobalBlock 程序的数据区域(.data区) 全局变量 保持在数据区
_NSConcreteMallocBlock 局部变量 增加引用计数

定义在全局的Block在变量作用域之外通过指针访问使用,定义在栈上的__block局部变量和Block在超出作用域时将被废弃。那Block超出作用域是如何存在的呢?

这里就用到Block的Copy操作,即将分配在栈上的Block 和__block变量复制到堆上,从而延长了Block和__block变量的生命周期。

那么,Block被复制到堆上的操作是何时进行的呢?

首先,比较明确的一点是:将Block作为返回值返回时,编译器将会自动将Block由栈上复制到堆上,其他情况下,需要手动执行Copy操作;在ARC有效的情况下,Block是否被复制到堆上,编译器会进行相关的判断;

举个栗子:

typedef int (^BlockCase)(int);BlockCase getBlockCallBack(int value) {    return ^(int count) {        return count + value;    };}

在ARC有效的情况下,作为返回值的Block会被复制到堆上。当然了,系统中存在的一些API是无需手动复制的:Cocoa框架方法中带有usingBlock方法、GCD相关的API等等。

__block变量的存储域

当在Block中使用__block变量时,当在Block从栈复制到堆上同时,被使用过的__block变量也会从栈复制到堆上。如下图所示:

__block变量所分配的存储域 Block从栈复制到堆上后的影响
由栈复制到堆上并被Block持有
被Block持有

__fawarding指针存在的意义

前边介绍了Block和__block变量从栈复制到堆上的情景,但都与__fawarding指针脱不开关系。

  • 由栈复制到堆之前,__fawarding指针指向自身;

  • 复制之后,栈上的__fawarding指针指向复制到堆上的__block变量,堆上的__fawarding指针指向自身。

    从而,解释了无论__block变量配置在栈上还是配置在堆上时都能正确的访问到__block变量;

Block截获对象

通过了解上节的内容,很好理解以下内容:

  • __block修饰的变量从栈复制到堆上,赋值给该__block变量的对象也被从栈复制到堆上,当__block变量从堆上释放时,该对象才能得到释放;

  • 当使用__weak修饰的__block变量在赋值的时候,由于赋值对象的作用域问题而释放,从而导致__block变量不能强持有该对象。

Block循环引用

形成原因:

  • 对象与Block相互持有;

  • 形成强持有环;

    解决方式:

  • 设置weak弱持有关系;

  • 手动置为nil,梳理好持有关系,破坏环状结构。

结束

关于Block就大致说到这吧,从Block的使用到Block的原理剖析,希望能让我们更客观的认识Block,写出更高质量的代码。

好久没有更新文章了,想必老铁们也都等着急了吧。主要是从2018年3月底更新后最后一篇文章,就一直在忙,关于那段时间的事情会在另一篇文章中详述。

谢谢大家的支持!

作者:Jack_lin

链接:https://www.swifty.cc/p/ad0a41981017

赞(0) 打赏
未经允许不得转载:云微资讯 » 重新回味·Block·
分享到: 更多 (0)

云微资讯 科技新媒体资讯平台

关于我们联系我们

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏