前言
从Objective-C的发展史引出了主题Block。在讲Block前，先熟悉了闭包的概念，然后了解到Block其实就是闭包的一种实现。闭包的实质就是捕获了外部变量的函数，Block要解决捕获变量和变量内存管理相关的问题。在使用时又用让编译器减少了我们使用的成本。第四、五部分在讲Block的内存管理时，又讲到了MRR环境和ARC环境循环引用的原因和解决方案
网上已经有很多篇关于Block的实现，为什么我还要再写一篇？有两个原因：其实在2014年底的时候，我写过一篇关于Block原理的文章，当时还有自己的博客，后来网站到期了，文章也丢了;(；另外我翻了很多网上的博客，发现并没有说明白循环引用产生的原因和为什么加了__block（MRR）、__weak（ARC）就能避免循环引用。
Objective-C发展史
Objective-C从1983年诞生，已经走过了30多年的历程。随着时间的推移，Objective-C支持了很多特性，下面是几个重要的发展节点：
● Object Oriented C —1983
● Retain and Release
● Properties —2006（Objective-C2.0发布）
● Blocks —Mac OS X 10.6(June 8, 2009) & iOS4.0(June 21, 2010)
● ARC —Mac OS X 10.6&iOS5(2011)
以上发展节点来自介绍ARC的WWDC视频➀，时间来自维基百科和其他网站。至于为什么会先说这些，主要我发现很多同学在了解一项技术时，没有一个立体的概念，经常看后会很快忘记。当我们对一个知识的来龙去脉了解时，这个知识点就不再是个点，而会变成一个面，起到帮助我们记忆的作用。另外我建议大家深入学习某项技术时，不要仅看一些人的分享，现在知识分享已经没有门槛，经常会看到人云亦云的博客（当然也可能包括我:)），最好的方式就是先从博客上了解知识，然后从官方途径上去学习验证。推荐大家几个网站，第一个当然是苹果的开发文档➁；第二个就是WWDC视频➂；如果你还是不尽兴，想从源码方面上了解，可以去看下苹果开放的源码-runtime➃、libDispatch➄、libclosure➅，和clang文档➆
Block的由来
闭包
在讲Block之前，我们先了解下闭包的概念：
在计算机科学中，闭包（英语：Closure），又称词法闭包（Lexical Closure）或函数闭包（function closures），是引用了自由变量的函数。这个被引用的自由变量将和这个函数一同存在，即使已经离开了创造它的环境也不例外。—维基百科➇
从上面维基百科的解释中，我们可以看到，一个闭包即有捕获自由变量的特性，又具有函数的特性。闭包在我们日常工作中，经常用于回调，尤其在延迟调用（也称为惰性求值）的情况下非常有用。比如我们经常需要在网络请求完成时更新UI，网络请求需要一定时间，在请求结束时再调用更新UI的方法。
Block
先从苹果官方文档上，看下关于Block的描述
Block objects are a C-level syntactic and runtime feature. They are similar to standard C functions, but in addition to executable code they may also contain variable bindings to automatic (stack) or managed (heap) memory. A block can therefore maintain a set of state (data) that it can use to impact behavior when executed.
简单来讲Block是Apple实现的闭包，它适用于C++，Objective-C，Objective-C++。另外Block需要runtime和clang的支持，下面会讲到
Block使用方式
先看一个使用Block的场景，摘一段苹果介绍Block的代码：
int multiplier = 7;
int (^myBlock)(int) = ^(int num) {
return num * multiplier;
};
Block的使用和函数指针使用非常相似，最大的不同，可能就是函数指针的*变成了^。下面我们看下Block有哪些东西
image
Block存储域
在iOS开发过程中，有三种不同类型的Block，分别是：
● _NSConcreteStackBlock， 栈上的Block，在出了作用域之后会被释放
● _NSConcreteMallocBlock，堆上的Block，在MRR环境需要手动释放
● _NSConcreteGlobalBlock，全局的Block，存在data区域，生命周期和应用一样
在我们初始化Block时只有_NSConcreteStackBlock/_NSConcreteMallocBlock两种类型。注意我们是无法生成_NSConcreteMallocBlock的，只有在_NSConcreteStackBlock调用__Block_copy时才会被copy到堆上，生成_NSConcreteMallocBlock。这一点可以从clang文档中了解到，可能现在看懂这些还比较困难，没关系，我们下面在Block内部实现会讲到。
有两个问题需要我们注意下：
在初始化Block时，我们怎么判断是_NSConcreteStackBlock还是_NSConcreteGlobalBlock？
这里有个快速判断的方法。如果Block的body里使用到了外部的非全局变量和非static静态变量，那么这个Block就会在栈上创建即_NSConcreteStackBlock。反之如果没有使用外部变量或者仅使用了全局变量或者static静态变量则是全局Block_NSConcreteGlobalBlock，下面有几个例子：
// _NSConcreteGlobalBlock
int multiplier = 7; // 全局变量
{
int (^myBlock)(int) = ^(int num) {
return num * multiplier;
};
}
// _NSConcreteGlobalBlock
static int multiplier = 7; // 静态变量
int (^myBlock)(int) = ^(int num) {
return num * multiplier;
};
// _NSConcreteStackBlock MRR环境
int multiplier = 7; // 局部变量或者实例变量
int (^myBlock)(int) = ^(int num) {
return num * multiplier;
};
// _NSConcreteMallocBlock ARC环境
// 注意这里虽然在打印myBlock时显示为NSMallocBlock，但是这并不是说我们创建出了_NSConcreteMallocBlock，而是被隐式地调用了copy
int multiplier = 7; // 局部变量或者实例变量
int (^myBlock)(int) = ^(int num) {
return num * multiplier;
};
Block在MRR环境和ARC环境下使用时，需要注意哪些情况？
1、在MRR环境下系统提供了两种方式把Block从栈上copy到堆上，第一种是显式调用copy，第二种是显式调用Block_copy宏。当然如果使用属性的话，则需要用copy标记，如
@property (copy) int(^Blk)(int) blk
而使用retain标记属性是不行的，大家可以试一下
2、在ARC环境下，编译器帮助我们自动插入了copy操作，省去了我们很多的工作量，以下几种情况编译器会隐式执行copy操作：
● 将Block作为函数返回值时
● 将Block赋值给__strong修改的局部变量，或者标记为strong和copy的属性时
● 向Cocoa框架含有usingBlock的方法或者GCD的API传递Block参数时
虽然上面的几种情况几乎涵盖了所有Block使用场景，不过仍然一种情况需要我们考虑到，就是把Block当方法参数传递给我们自定义方法时进行传递时，系统是不帮我们copy的，在使用时需要我们手动进行copy，如：
{
int multiplier = 7;
print(^(int num) {
return num * multiplier;
};)
}
void print(Blk blk) {
// NSStackBlock
blk(1);
}
Block的内部实现
在看源码之前，我们先大概捋下如果让我们自己实现一个闭包时怎么实现，或者需要考虑什么？比如如何捕获外部变量；如何管理外部变量的内存；调用方式是怎样的？如果解决了这些问题，我们也能写一个闭包的实现，无非是没有编译器的加持，调用起来不是那么优雅。好了，说了这么多，我们带着这些疑问去看Block的实现源码，思路会更加清晰。
我们先准备好clang里的说明文档➉（这个文档解释Block内部实现）和Block实现源码➅。
Block的实现主要包括四个文件：Block.h、Block_private.h、data.c、runtime.c
Block.h
BLOCK_EXPORT void *_Block_copy(const void *aBlock);
BLOCK_EXPORT void _Block_release(const void *aBlock);
#define Block_copy(...) ((__typeof(__VA_ARGS__))_Block_copy((const void *)(__VA_ARGS__)))
#define Block_release(...) _Block_release((const void *)(__VA_ARGS__))
这个文件包括Block向外提供的方法，我们可以看到Block_copy宏实现，其实就是调用了_Block_copy方法，Block_release宏调用了_Block_release方法，所以我们也可以将宏调用改为方法调用。这个文件是暴露出去的，我们可以在工程中看到：路径在/usr/include/Block.h，这四个文件只有这个文件是暴露的，用来给我们调用
data.c
BLOCK_EXPORT void * _NSConcreteStackBlock[32] = { 0 };
BLOCK_EXPORT void * _NSConcreteMallocBlock[32] = { 0 };
BLOCK_EXPORT void * _NSConcreteGlobalBlock[32] = { 0 };
BLOCK_EXPORT void * _NSConcreteAutoBlock[32] = { 0 }; // only used in GC
BLOCK_EXPORT void * _NSConcreteFinalizingBlock[32] = { 0 }; // only used in GC
BLOCK_EXPORT void * _NSConcreteWeakBlockVariable[32] = { 0 }; // only used in GC
这个文件定义了6种Block类型。其中后三种类型只有GC环境才会出现，因为GC在ARC推出后，已被苹果废弃了。所以我们只关心前三种类型即可，这也印证了我们上面说的三种Block类型
Block_private.h
这个文件描述了Block的具体结构
runtime.c
这个文件描述了Block的copy/release和Block持有变量的copy/release操作。
好了，这就是Block的所有文件，Block_private.h和runtime.c两个文件是我们需要重点关注。哦，其实还有一个关联的文件没说，先放着不管，在讲到runtime.c会引出该文件，这个文件很重要，如果没有这个文件我们在阅读到某块代码时会有点莫名其妙。
以下分两部分详细分析Block的实现：
1、Block内部结构，分析Block怎样实现捕获变量；函数调用，实现在Block_private.h
2、Block内存管理，分析怎么管理Block内存；怎么管理捕获的变量的内存，实现在runtime.c
Block内部结构
首先我们从Block内部结构说起，上面我们已经讲到，它在Block_private.h文件中，先贴下Block的结构代码
#define BLOCK_DESCRIPTOR_1 1
/* Block描述1
* 如果是_NSConcreteStackBlock时，在copy到堆上时，需要确定Block的大小，用来在堆上分配空间
*/
struct Block_descriptor_1 {
uintptr_t reserved;
uintptr_t size; // Block's size
};
#define BLOCK_DESCRIPTOR_2 1
/* Block描述2
* 如果是_NSConcreteStackBlock并且捕获了__block修饰的变量或者(id, NSObject, __attribute__((NSObject)), block, ...）类型的变量，在copy到堆上时需要生成copy方法，这个方法用来解决捕获的变量在被copy时要执行的动作。
* 如果是_NSConcreteGlobalBlock则不会生成该结构
*/
struct Block_descriptor_2 {
// requires BLOCK_HAS_COPY_DISPOSE
void (*copy)(void *dst, const void *src);
void (*dispose)(const void *);
};
// Block的内部布局
struct Block_layout {
void *isa; // initialized to &_NSConcreteStackBlock or &_NSConcreteGlobalBlock
volatile int32_t flags; // contains ref count 这个值主要用来告知系统Block在copy时应该执行什么操作
int32_t reserved;
void (*invoke)(void *, ...); // function ptr
struct Block_descriptor_1 *descriptor;
// imported variables
};
从上面我们可以了解到，Block由三个struct构成，每个struct都做了详细的注释。这里注意下Block_layout中的flags，这个值在Block调用copy时会用到
// Values for Block_layout->flags to describe block objects
// 已删掉GC环境需要的值
enum {
BLOCK_REFCOUNT_MASK = (0xfffe), // runtime
BLOCK_NEEDS_FREE = (1 << 24), // runtime
BLOCK_HAS_COPY_DISPOSE = (1 << 25), // compiler
BLOCK_IS_GLOBAL = (1 << 28), // compiler
};
其中是BLOCK_HAS_COPY_DISPOSE和BLOCK_IS_GLOBAL是由编译器根据上下文生成的。另外两个是在Block被copy时，runtime用到和修改的，这里的runtime特指runtime.c文件，在分析runtime.c文件时，再具体说明。
Block在捕获非全局和非静态变量时，都是copy的不可变变量，在Block的body里是不能修改这个值的，编译器会给我们提示如：
（注解：Block的body里使用全局变量或者静态变量，这些变量并不会进行copy，它只做使用，也不会去管理这些变量的内存，如果Block仅仅使用了全局变量或者静态变量，Block为_NSConcreteGlobalBlock类型）
image
如果需要修改变量值，我们可以通过__block修饰变量：
__block int multiplier = 7; // 局部变量
int (^myBlock)(int) = ^(int num) {
multiplier = 5;
return num * multiplier;
};
myBlock(1);
__block修饰的变量会被Block_byref这样的结构包起来，具体如下
struct Block_byref {
void *isa;
struct Block_byref *forwarding; // 初始化时会指向自己，当Block被copy时，Block_byref也会被copy到堆上，forwarding会指向堆上的Block_byref
volatile int32_t flags; // contains ref count
uint32_t size; // Block_byref大小，用来copy时分配内存
};
// Block_byref被copy到堆上和释放时需要的操作
struct Block_byref_2 {
// requires BLOCK_BYREF_HAS_COPY_DISPOSE
void (*byref_keep)(struct Block_byref *dst, struct Block_byref *src);
void (*byref_destroy)(struct Block_byref *);
};
如果变量属于id, NSObject, __attribute__((NSObject)), block, …这种对象类型（后面以“对象类型”代替），则会生成Block_byref_2结构体，里面包括byref_keep和byref_destroy方法，来管理被它包裹的变量的内存，如果是修饰的是自动变量如int，CGPoint，enum类型，则不会生成结构体Block_byref_2
Block_private.h文件描述了Block通过结构体来捕获变量，当捕获的变量是对象类型时，会生成copy/dispose方法来管理被捕获的变量的内存；为了支持变量可以在Block的body里修改，可以使用__block修饰要修改的变量，通过byref_keep/byref_destroy管理内存
Block内存管理
内存管理部分的实现在另外一个文件runtime.c。该文件包含了:
● Block本身的内存管理_Block_copy和_Block_release；
● 被捕获的对象类型变量的内存管理_Block_object_assign和_Block_object_dispose
● __block修饰的变量的内存管理_Block_byref_copy和_Block_byref_release
copy和release/dispose是逆操作，如果掌握了三个copy操作，逆操作理解起来就很简单了，所以以下仅对copy操作进行分析
I. Block的copy方法：_Block_copy
Block的copy方法
Block的copy方法
这个方法通过aBlock->flags确定不同类型Block应该怎么copy，flags的值在分析Block内部结构中已做说明，
当flags为BLOCK_IS_GLOBAL即Block为_NSConcreteGlobalBlock（全局Block）时直接返回不做任何操作
void *_Block_copy(const void *arg) {
struct Block_layout *aBlock;
// The following would be better done as a switch statement
aBlock = (struct Block_layout *)arg;
...
else if (aBlock->flags & BLOCK_IS_GLOBAL) {
return aBlock;
}
...
}
当为BLOCK_HAS_COPY_DISPOSE即Block为_NSConcreteStackBlock（栈Bock）时，则在堆上生成同样大小的Block，把堆上的Block的flags改为BLOCK_HAS_COPY_DISPOSE|BLOCK_NEEDS_FREE|2，把isa指向_NSConcreteMallocBlock（堆Block）
void *_Block_copy(const void *arg) {
struct Block_layout *aBlock;
// The following would be better done as a switch statement
aBlock = (struct Block_layout *)arg;
...
else {
// Its a stack block. Make a copy.
struct Block_layout *result = malloc(aBlock->descriptor->size);
if (!result) return NULL;
memmove(result, aBlock, aBlock->descriptor->size); // bitcopy first
// reset refcount
result->flags &= ~(BLOCK_REFCOUNT_MASK|BLOCK_DEALLOCATING); // XXX not needed
result->flags |= BLOCK_NEEDS_FREE | 2; // logical refcount 1
_Block_call_copy_helper(result, aBlock);
// Set isa last so memory analysis tools see a fully-initialized object.
result->isa = _NSConcreteMallocBlock;
return result;
}
}
当Block从栈上copy到堆上时，另外会调用_Block_call_copy_helper方法。在讲Block内部结构时讲到，如果捕获的变量为对象类型或者__block修饰时，会生成Block_descriptor_2，进而调用其copy方法，这个方法最终会调到_Block_object_assign用来管理被捕获的变量；如果捕获的变量为值类型，则不会生成Block_descriptor_2，也不需要管理变量内存
static void _Block_call_copy_helper(void *result, struct Block_layout *aBlock)
{
struct Block_descriptor_2 *desc = _Block_descriptor_2(aBlock);
if (!desc) return;
(*desc->copy)(result, aBlock); // do fixup
}
如果Block已经被copy到堆上，再调用copy方法，则只需要增加Block的引用计数即可，Block在连续调用Block_copy/copy时仅增加了Block的引用计数，并没有增加对Block持有的变量的引用计数
void *_Block_copy(const void *arg) {
struct Block_layout *aBlock;
// The following would be better done as a switch statement
aBlock = (struct Block_layout *)arg;
if (aBlock->flags & BLOCK_NEEDS_FREE) {
// latches on high
latching_incr_int(&aBlock->flags);
return aBlock;
}
...
}
II. 对象类型/__block修饰变量的copy_Block_object_assign方法
对象类型/__block修饰变量的copy_Block_object_assign方法
对象类型/__block修饰变量的copy_Block_object_assign方法
上面已经讲过，只有被捕获的变量是对象类型或者__block修饰的变量才需要内存管理。如果为对象类型，则flags为BLOCK_FIELD_IS_OBJECT，从上面可以看到调用了_Block_retain_object
void _Block_object_assign(void *destArg, const void *object, const int flags) {
const void **dest = (const void **)destArg;
switch (os_assumes(flags & BLOCK_ALL_COPY_DISPOSE_FLAGS)) {
case BLOCK_FIELD_IS_OBJECT:
_Block_retain_object(object);
*dest = object;
break;
...
}
}
_Block_retain_object方法默认什么也没做，如果在MRR环境下，libDispatch会调用_Block_use_RR2方法为_Block_retain_object方法赋值为retain操作，具体调用看object.m➈这个文件的void_os_object_init(void)方法，但是在ARC环境下，该文件是不会编译的，文件中也做了说明
object.m
#if _OS_OBJECT_OBJC_ARC
#error "Cannot build with ARC"
#endif
_Block_retain_object实现如下
static void _Block_retain_object_default(const void *ptr __unused) { }
// 默认_Block_retain_object被赋值为_Block_retain_object_default，即什么都不做
static void (*_Block_retain_object)(const void *ptr) = _Block_retain_object_default;
// Called from CF to indicate MRR. Newer version uses a versioned structure, so we can add more functions
// without defining a new entry point.
// 上面的注释其实不是libclosure-65版本的，我从libclosure-63版本摘过来的，不知道苹果为啥把这个注释去掉了，让人读起源码来，会感觉莫名其妙
void _Block_use_RR2(const Block_callbacks_RR *callbacks) {
_Block_retain_object = callbacks->retain;
_Block_release_object = callbacks->release;
_Block_destructInstance = callbacks->destructInstance;
}
通过上面的分析，可以知道如果在MRR环境下，Block会通过_Block_retain_object方法持有对象类型变量。而在ARC环境下，_Block_retain_object方法是个空操作，并不会持有该类型变量。那ARC环境下Block怎么样达到持有对象类型的变量呢？ARC环境有了更完善的内存管理，如果外部变量由strong、copy、strong修饰时，Block会把捕获的变量用strong来修饰进而达到持有的目的。
在使用Block时，最大的困扰就是RetainCycle（循环引用），比如：对象A持有了Block，Block又持有了对象A。因为Block持有了对象A，所以对象A想释放则必须要先释放Block，而Block又由于被对象A持有也释放不了，这就造成了循环引用。解决循环引用有两种办法，一种是手动把Block置为nil来释放Block对对象A的引用；另外一种就是禁止Block强持有对象A，在MRR和ARC环境下禁止Block持有对象A的做法是不一样，ARC环境下只需要把变量加上__weak修饰就可以避免Block持有变量；而在MRR环境下只能通过避免调用_Block_retain_object方法，怎么避免呢，可以往下继续看
（这里吐槽下，苹果的文档真是乱，有些文件在好几个库都有，找起来很麻烦不说，libDispatch里面竟然也有Block实现，看文档的日期，竟然比libclosure-65还新，一度让我不知道该看哪个，最后我发现，libDispatch里的版本其实不是最新的Block实现，比如libclosure-65版本废弃了_Block_use_RR方法，彻底使用_Block_use_RR2按照文档上的解释，说这种调用方式可以随意增加方法;(）
当变量由__block修饰时，该变量会被打包成Block_byref类型，flags会被标记为BLOCK_FIELD_IS_BYREF，
void _Block_object_assign(void *destArg, const void *object, const int flags) {
const void **dest = (const void **)destArg;
switch (os_assumes(flags & BLOCK_ALL_COPY_DISPOSE_FLAGS)) {
...
case BLOCK_FIELD_IS_BYREF:
*dest = _Block_byref_copy(object);
break;
...
}
}
我们可以看到实际上是调用了_Block_byref_copy方法
该方法先在堆上生成同样大小的Block_byref赋值给堆上的Block，并把flags设置为src->flags | BLOCK_BYREF_NEEDS_FREE | 4，
image
从上面可以看到当Block_byref被copy到堆上时，如果__block修饰的对象类型会调用Block_byref的copy方法，该方法又会调用_Block_object_assign方法，如果__block修饰的变量是id, NSObject, __attribute__((NSObject))类型，则flags会被设置成BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_OBJECT，
void _Block_object_assign(void *destArg, const void *object, const int flags) {
const void **dest = (const void **)destArg;
switch (os_assumes(flags & BLOCK_ALL_COPY_DISPOSE_FLAGS)) {
...
case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_OBJECT:
case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_BLOCK:
*dest = object;
break;
...
}
}
我们看到仅仅做了赋值操作。所以通过block修饰可以避免调用到_Block_retain_object方法，也就是在MRR环境下我们可以通过block来避免Block强持有变量，进而避免循环引用
当然Block也支持嵌套Block使用，flags会被标记为BLOCK_FIELD_IS_BLOCK，被捕获的Block被copy就是调用上面的_Block_copy方法
void _Block_object_assign(void *destArg, const void *object, const int flags) {
const void **dest = (const void **)destArg;
switch (os_assumes(flags & BLOCK_ALL_COPY_DISPOSE_FLAGS)) {
...
case BLOCK_FIELD_IS_BLOCK:
*dest = _Block_copy(object);
break;
...
}
}
III. 回顾下runtime.c的几个方法
_Block_copy方法用来确定_NSConcreteStackBlock、_NSConcreteGlobalBlock、_NSConcreteMallocBlock三种类型在Block调用copy时执行的动作
_Block_object_assign方法用来确定Block捕获了对象类型变量和__block修饰的变量在Block从栈上copy到堆上时执行的动作
_Block_byref_copy方法用来确定被__block修饰的变量在Block从栈上copy到堆上时执行的动作
IV. Block捕获不同类型变量的内存管理总结：
● 当外部变量是全局变量或者static静态变量时，只使用且不需要管理内存；
● 当外部变量是值类型如int、CGPoint时进行值const copy，不需要管理内存；
● 直接使用实例变量，则捕获self
● 如果把实例变量赋值给临时变量，在Block内使用这个临时变量，则捕获实例变量
● 当外部变量是对象型变量id, NSObject, __attribute__((NSObject))时，进行指针const copy，在Block被copy到堆上时增加引用计数用来持有该变量，在MRR环境通过_Block_retain_object方法持有变量，在ARC环境下通过__strong持有变量。这里是解决循环引用的关键
● 当外部变量被__block修饰时，会使用Block_byrefstruct包装该变量，在Block被copy到堆上时copyBlock_byref，如果__block修饰的是id, NSObject, __attribute__((NSObject))对象型类型，该变量只做指针copy不会增加变量的引用计数。当__block修饰的是值类型时，做值const copy
● 当外部变量是block类型时，在Block被copy到堆上时，调用_Block_copy 进行持有，如果外部block类型变量也持有变量，则递归进行copy
Block使用-续
第三部分讲到Block怎么样使用，第五部分讲到了Block的内部结构和内存管理。这里大家可能有个疑问，Block在使用时，并没有声明那一堆struct啊，而且像什么isa、flags值都是谁设置的呢？
先看下Block使用例子：
int multiplier = 7;
int (^myBlock)(int) = ^(int num) {
return num * multiplier;
};
再看下Block_private.h文件中Block的结构：
struct Block_descriptor_1 {
uintptr_t reserved;
uintptr_t size; // Block's size
};
struct Block_descriptor_2 {
// requires BLOCK_HAS_COPY_DISPOSE
void (*copy)(void *dst, const void *src);
void (*dispose)(const void *);
};
// Block的内部布局
struct Block_layout {
void *isa; // initialized to &_NSConcreteStackBlock or &_NSConcreteGlobalBlock
volatile int32_t flags; // contains ref count 这个值主要用来告知系统Block在copy时应该执行什么操作
int32_t reserved;
void (*invoke)(void *, ...); // function ptr
struct Block_descriptor_1 *descriptor;
// imported variables
};
正常来讲，我们应该先声明Block_layout对象，然后实现invoke方法，告知系统Block是_NSConcreteStackBlock还是_NSConcreteGlobalBlock，再实现BLOCK_DESCRIPTOR_2的copy方法，管理捕获的对象的内存。这样做有个很明显的问题：调用方式太麻烦了，而且需要我们深刻理解Block_layout里每个变量的含义，稍不留神就会出错。为了让我们使用更简单，这一堆变量的设置都交给了编译器去实现。编译器可以聪明地把上面的结构转成下面的结构。这里我们借助编译器前端clang，使用clang -rewrite-objc xxx.m命令重写成c++代码，看下编译器是怎么转换的
好了，我们先建个工程，假设叫BlockImpl；然后创建文件，比如也叫BlockImpl，把上面那段代码copy进来
#import "BlockImpl.h"
@implementation BlockImpl
- (void)test {
int multiplier = 7; // 局部变量
int (^myBlock)(int) = ^(int num) {
return num * multiplier;
};
myBlock(1);
}
@end
然后，我们在终端中输入命令clang -rewrite-objc BlockImpl.m（当然你首先要cd 该文件所在文件夹:)）,回车，你会发现在BlockImpl.m同级文件夹中生成了一个名字叫BlockImpl.cpp文件。这个文件就是重写后的c++文件。几行代码被重写成将近10万行代码，没事儿，不要怕，我们只需要关注跟我们相关的代码，在这我把相关代码摘出来，如下：
struct __block_impl {
void *isa;
int Flags;
int Reserved;
void *FuncPtr;
};
// @implementation BlockImpl
struct __BlockImpl__test_block_impl_0 {
struct __block_impl impl;
struct __BlockImpl__test_block_desc_0* Desc;
const int multiplier;
__BlockImpl__test_block_impl_0(void *fp, struct __BlockImpl__test_block_desc_0 *desc, int _multiplier, int flags=0) : multiplier(_multiplier) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static int __BlockImpl__test_block_func_0(struct __BlockImpl__test_block_impl_0 *__cself, int num) {
int multiplier = __cself->multiplier; // bound by copy
return num * multiplier;
}
static struct __BlockImpl__test_block_desc_0 {
size_t reserved;
size_t Block_size;
} __BlockImpl__test_block_desc_0_DATA = { 0, sizeof(struct __BlockImpl__test_block_impl_0)};
static void _I_BlockImpl_test(BlockImpl * self, SEL _cmd) {
int multiplier = 7;
int (*myBlock)(int) = ((int (*)(int))&__BlockImpl__test_block_impl_0((void *)__BlockImpl__test_block_func_0, &__BlockImpl__test_block_desc_0_DATA, multiplier));
((int (*)(__block_impl *, int))((__block_impl *)myBlock)->FuncPtr)((__block_impl *)myBlock, 1);
}
// @end
摘完后，代码是不是清爽了许多，好了，下一步我们就尝试对应下，看看重写后的代码是不是和Block_private.h文件中定义的结构一样：
1、__BlockImpl__test_block_impl_0 和__block_impl加起来对应上了Block_layout。这里有个知识点注意下，struct并没有改变变量在内存的位置，所以这两个是可以划等号的
2、__BlockImpl__test_block_desc_0和Block_descriptor_1对应
3、Block的body被转换成了函数指针__BlockImpl__test_block_func_0
从上面的分析，可以看到它们俩是完全可以对应上的。另外我们也可以看到系统为做了一些自动化的工作，比如:
1、为isa赋值&_NSConcreteStackBlock；
2、myBlock(1)调用转换为函数调用((int (*)(__block_impl *, int))((__block_impl *)myBlock)->FuncPtr)((__block_impl *)myBlock, 1);；
3、局部变量multiplier被copy到了__BlockImpl__test_block_impl_0上，函数调用时也是使用的__BlockImpl__test_block_impl_0的multiplier值，而不是那个局部变量，这也说明了Block不能随意地修改外部局部变量（当然添加__block修饰符才可以，第三、五部分有讲到原因）
clang -rewrite-objc BlockImpl.m以MRR方式重写，如果要想要以ARC方式，加上-fobjc-arc和-fobjc-runtime=macosx-10.7，即clang -rewrite-objc -fobjc-arc -fobjc-runtime=macosx-10.7 BlockImpl.m，通过-rewrite-object命令重写下你的应用吧，结合第四部分，你会更加深刻了解Block
循环引用
很多人搞不明白，ARC的循环引用是怎么引起的，总以为和MRR是一样的，其实第四部分已经说明过一次了，在这里单拎出来强调下。MRR环境下通过_Block_retain_object方法实现强引用外部变量，这个可以自己写下代码用-rewrite-objc命令重写下，很容易理解。在ARC环境_Block_retain_object其实是个空操作，在第四部分已经说明。ARC是通过__strong实现变量的持有的，下面我们写一个循环引用的例子
@interface BlockImpl ()
@property (nonatomic, copy) void (^myBlock)(int);
@end
@implementation BlockImpl
- (void)testRetainCycle {
self.myBlock = ^(int num) {
NSLog(@"%@", self);
};
self.myBlock(1);
}
@end
使用clang -rewrite-objc -fobjc-arc -fobjc-runtime=macosx-10.7 BlockImpl.m，得到
***
// 只贴出来关键部分
struct __BlockImpl__testRetainCycle_block_impl_0 {
struct __block_impl impl;
struct __BlockImpl__testRetainCycle_block_desc_0* Desc;
BlockImpl *const __strong self; // 看这里，Block通过__strong持有了self
__BlockImpl__testRetainCycle_block_impl_0(void *fp, struct __BlockImpl__testRetainCycle_block_desc_0 *desc, BlockImpl *const __strong _self, int flags=0) : self(_self) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
***
如果禁止Block的持有，则只能通过__weak修饰self，如下
@interface BlockImpl ()
@property (nonatomic, copy) void (^myBlock)(int);
@end
@implementation BlockImpl
- (void)testRetainCycle {
__weak __typeof(self) weakSelf = self;
self.myBlock = ^(int num) {
NSLog(@"%@", weakSelf);
};
self.myBlock(1);
}
@end
转化为
struct __BlockImpl__testRetainCycle_block_impl_0 {
struct __block_impl impl;
struct __BlockImpl__testRetainCycle_block_desc_0* Desc;
BlockImpl *const __weak weakSelf; // 看这里，__weak修饰，Block不再强持有self
__BlockImpl__testRetainCycle_block_impl_0(void *fp, struct __BlockImpl__testRetainCycle_block_desc_0 *desc, BlockImpl *const __weak _weakSelf, int flags=0) : weakSelf(_weakSelf) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
所以ARC环境下__weak可以解决循环引用
其它
最后感谢你花了这么长时间看我的这篇絮絮叨叨的文章:)
文章涉及到链接：
➁ 苹果官方开发文档： https://developer.apple.com/library/content/navigation/
➂ WWDC视频：https://developer.apple.com/videos/
➃ runtime源码：https://opensource.apple.com/source/objc4/
➄ libDispatch源码：https://opensource.apple.com/source/libdispatch/libdispatch-913.1.6/src/
➅ Block源码：https://opensource.apple.com/source/libclosure/
➆ clang文档：http://clang.llvm.org/docs/index.html
➇ 闭包-维基百科：https://zh.wikipedia.org/wiki/闭包_(计算机科学)
➈ __Block_use_RR2 ：https://opensource.apple.com/source/libdispatch/libdispatch-913.1.6/src/object.m.auto.html
➉ clang介绍Block：http://clang.llvm.org/docs/Block-ABI-Apple.html
本文非原创
网友评论