老生常谈之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;
};
从属性变量的名字我们可以猜测出该结构体各个属性的含义：
- isa：isa指针，指向父类的指针。
- Flags：一个标记
- Reserved：预留区域，用于以后的使用。
- 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的存储域有以下几种：
- _ NSConcreteStackBlock,该类的对象Block设置在栈上
- _ NSConcreteGlobalBlock,该类的Block设置在程序的数据区(.data)域中。
- _ 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多线程和内存管理》一书。
