老生常谈之Block

前面有一篇介绍 Block的博客 ,主要介绍了Block的简单使用技巧。这篇博客主要更加深入地了解一下Block。包括:Block的实现、__Block的原理以及Block的存储域三方面。

Block的实现

首先我们使用Xcode创建一个Project,点击File–>New–>Project,选择macOS中Application的Command Line Tool,然后设置Project Name即可。你好发现这个工程值包含了一个main.m文件,然后我们做如下更改(更改后的代码如下):

#import <stdio.h>

int main(int argc, const char * argv[]) {
    printf("Hello World");
    return 0;
}

这个是我们最常见的C代码,导入stdio.h,然后打印出来Hello World。接下来我们写一个最简单的block,没有返回值,没有传入参数:

#import <stdio.h>

int main(int argc, const char * argv[]) {
    
    void (^blk)(void) = ^{
        printf("Hello Worldddd");
    };
    blk();
    return 0;
}

打印出来的结果相当于调用了blk输出的结果。接下来我们在item中跳转到main.m所在文件夹然后执行如下命令:

clang -rewrite-objc main.m

你会发现在当前文件夹下生成了一个.cpp文件,它是经过clang编译器编译之后的文件,打开之后里面大概有5百多行,其实我们看下面的这些代码就足够了:

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
#ifndef BLOCK_IMPL
#define BLOCK_IMPL
struct __block_impl {
    void *isa;
    int Flags;
    int Reserved;
    void *FuncPtr;
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {

        printf("Hello Worldddd");
    }

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};
int main(int argc, const char * argv[]) {

    void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
    ((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
    return 0;
}

其中包含三个结构体:

__main_block_impl_0、__block_impl、__main_block_desc_0

和两个方法:

__main_block_func_0、main

main就是我们写的main函数。

至此,你能知道的就是:Block看上去很特别,其实就是作为及其普通的C语言源代码来处理的。编译器会把Block的源代码转换成一般的C语言编译器能处理的源代码,并作为极为普通的C语言源代码被编译。

接下来对编译的内容来一个分解,首先是

^{printf("Hello Worldddd")};

变换后的源代码如下:

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {

        printf("Hello Worldddd");
    }

也就是现在变成了一个静态方法,其命名方式为:Block所属的函数名(main)和该Block语法在函数出现的顺序值(0)来给经过clang变换的函数命名。该方法的参数相当于我们在OC里面的指向自身的self。我们看一下该参数的声明:

struct __main_block_impl_0 *__cself

你会发现它其实是一个结构体,该结构体的声明如下:

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

该结构体中你会发现里面有一个构造函数,你忽略构造函数,会发现该结构体就很简单了,只是包含了impl和 Desc两个属性变量。其中impl也是一个结构体,它的结构如下:

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

从属性变量的名字我们可以猜测出该结构体各个属性的含义:

  1. isa:isa指针,指向父类的指针。
  2. Flags:一个标记
  3. Reserved:预留区域,用于以后的使用。
  4. FuncPtr:这个很重要,是一个函数指针。后面会详细说明它的作用。

第二个变量是Desc,也是一个结构体:

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};

这个结构体就比较简单了,一个预留位,一个是指代该Block大小的属性,后面又包含了一个该实例:

__main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};

预留位为0,大小为传入结构体的大小。接下来就是很重要的构造函数了:

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

其中的&_NSConcreteStackBlock用于初始化impl的isa指针;flags为0;FuncPtr是构造函数传过来的fp函数指针;Desc为一个block的描述。到这里三个结构体和一个函数就介绍完了。接下来看一下main函数里面上述构造函数是如何调用的:

void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));

感觉好复杂,我们先做一个转换:

struct __main_block_impl_0 tmpeImpl = __main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA)

struct __main_block_impl_0 *blk = &tmpeImpl;

也就是说把结构体的实例的指针赋值给blk。接下来再看一下构造函数的的初始化,其实赋值就变成了这样:

impl.isa = &_NSConcreteStackBLock;
impl.Flags = 0;
impl.FuncPtr = __main_block_func_0;
Desc = &__main_block_desc_0_DATA;

现在在看一下调用block的那句代码:

blk();

转换成了:

((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);

这个转换不是太明白,但是知道他的作用就是把blk当做参数传进去,调用的FuncPtr所指向的函数,也就是_ block block func 0。

到这里就大体了解了Block的实现,其实就是C的几个结构体和方法,经过赋值和调用,进而实现了Block。

另外Block其实实质上也是OC的对象。

__Block的原理

先看一个简单的例子:

#import <stdio.h>

int main(int argc, const char * argv[]) {
    int i = 3;
    void (^blk)(void) = ^{
        printf("Hello World,%d",i);
    };
    blk();
    return 0;
}

使用clang编译后是这样的:

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

        printf("Hello World,%d",i);
    }

int main(int argc, const char * argv[]) {
    int i = 3;
    void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, i));
    ((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
    return 0;
}

也就是在main函数调用的时候把i传到了构造函数里,然后通过i( i)对结构体的属性变量i赋值,i变量现在已经成为了结构体的一个树形变量。在构造函数执行时把i赋值。在 __ main block func 0里面通过 __ cself调用,这个变量实际是在声明block时,被复制到了结构体变量i,因此不会影响变量i的值。当我们尝试在Block中去修改时,你会得到如下错误:

Variable is not assignable(missing __block type specifier)

提示我们加上__block,接下来我们将源代码做如下修改:

int main(int argc, const char * argv[]) {
    __block int i = 3;
    void (^blk)(void) = ^{
        i = i + 3;
        printf("Hello World,%d",i);
    };
    blk();
    return 0;
}

运行一下你会发现你成功对i的值进行了修改!用clang进行编译,结果如下:

struct __Block_byref_i_0 {
  void *__isa;
__Block_byref_i_0 *__forwarding;
 int __flags;
 int __size;
 int i;
};

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __Block_byref_i_0 *i; // by ref
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_i_0 *_i, int flags=0) : i(_i->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  __Block_byref_i_0 *i = __cself->i; // bound by ref

        (i->__forwarding->i) = (i->__forwarding->i) + 3;
        printf("Hello World,%d",(i->__forwarding->i));
    }
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->i, (void*)src->i, 8/*BLOCK_FIELD_IS_BYREF*/);}

static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->i, 8/*BLOCK_FIELD_IS_BYREF*/);}

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
  void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*);
  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};

int main(int argc, const char * argv[]) {
    __attribute__((__blocks__(byref))) __Block_byref_i_0 i = {(void*)0,(__Block_byref_i_0 *)&i, 0, sizeof(__Block_byref_i_0), 3};
    void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_i_0 *)&i, 570425344));
    ((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
    return 0;
}
你会发现多了一个

Block _ byref i 0的结构体,然后多了两个copy和dispose函数。

看一下main函数里面的i,此时也不再是一个简单的基本类型int,而是一个初始化的

Block byref i 0的结构体,该结构体有个属性变量为i,然后把3赋值给了那个属性变量。该结构体还有一个指向自己的指针

forwarding,它被赋值为i的地址。

现在

main block func 0在实现中使用了指向该变量的指针,所以达到了修改外部变量的作用。

Block的存储域

Block的存储域有以下几种:

  1. _ NSConcreteStackBlock,该类的对象Block设置在栈上
  2. _ NSConcreteGlobalBlock,该类的Block设置在程序的数据区(.data)域中。
  3. _ NSConcreteMallocBlcok,该类的Block设置在堆上
    下面这张图展示了Block的存储域:

我们前面看到的都是在Stack的Block,但是你可以在OC工程中打印一下你声明的block的isa,你会发现它其实是Malloc的block,也就是在堆上的block。如图:

还有一种情况是Global的block:

在ARC中,只有NSConcreteGlobalBlock和NSConcreteMallockBlock两种类型的block。因为我们最简单的block在工程中打印出来的都是MallocBlock。也许是因为苹果把对象都放到了堆管理,而Block也是对象,所以也放到了堆上。

此时我们也许会有个疑问:Block超出了变量作用域为什么还能存在呢?

对于Global的Block,变量作用域之外也可以通过指针安全使用,但是设置在栈上的就比较尴尬了,作用域结束后,Block也会 被废弃。为了使Block超出变量作用域还可以存在,Block提供了将Block和 __ block变量从栈上复制到堆上的方法来解决这个问题。这样就算栈上的废弃,堆上的Block还可以继续存在。

看一下对Block进行复制,结果如何:

如果对Block进行了copy操作, block的变量也会受到影响,当 block的变量配置在栈上,复制之后它将从栈复制到堆上并被Blcok持有,如果是堆上的

block变量,Blcok复制之后该变量被Block持有。

如果两个block(block1,block2)同时都是用

block变量,如果block1被复制到了堆上,那么 block变量也会在block1复制到堆的同时复制到堆上,当block2再是用到 block变量的时候,只是增加堆上 block变量的引用计数,不会再次复制。如果堆上的block1和block2被废弃了,那么它所是用的 block变量也就被释放了(如果block1被废弃,而block2没有被废弃,那么 block变量的引用计数-1,直到最后使用 block变量的block被废弃的同时,堆上的

block也会被释放)。

理解了上面刚才说的复制之后,现在回过来思考另一个问题:

block的时候转换的结构体中的 forwarding指针有什么作用呢?(下面代码中的 forwarding)
struct __Block_byref_i_0 {
  void *__isa;
__Block_byref_i_0 *__forwarding;
 int __flags;
 int __size;
 int i;
};

其实是这样的:栈上的 block变量用结构体实例在 block变量从栈复制到堆上的时候,会将成员变量 forwarding的值替换为复制目标堆上的 block变量用结构体实例的地址。通过该操作之后,无论是在Block语法中、Block语法外使用 block变量,还是 block变量配置在栈上或者堆上,都可以顺利地访问同一个 __ block变量。

以上便是对block的进一步介绍,主要参考了《Objective-C高级编程 iOS与OS X多线程和内存管理》一书。

我来评几句
登录后评论

已发表评论数()

相关站点

+订阅
热门文章