重新回味·Block·

Block-Mind

说起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);

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;
}

编译的时候会出现错误:

错误信息

看到这,你会感到疑惑,上面刚讲到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中修改截获的局部变量又会带来什么样的问题呢?

修改截获的局部变量

通过上面的代码可以看出,虽然在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_0Block__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月底更新后最后一篇文章,就一直在忙,关于那段时间的事情会在另一篇文章中详述。

谢谢大家的支持!

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

扫码关注云+社区

领取腾讯云代金券