前言
block可以叫回调代码块，是iOS开发中至关重要的形式之一。不同的编程语言都会用到block, 只是体现形式有所不同，例如c/c++叫函数指针，javascript叫它闭包。它用简单的方式帮我们解决了很多复杂的问题。
block如何将变量传递及持有
测试代码：
传递原则：
- 捕获对象是
基础类型变量，如int, double类型时，是值传递。 - 捕获对象是一个object，那么它会被强引用
我们来验证一下，我们在block赋值之后修改a的值
ViewController.m:
int a = 10;
_foo.testBlock= ^() {
_testView.backgroundColor = nil;//持有了self
NSLog(@"a:%d", a);
};
a+= 10;
_foo.testBlock();
输出结果:仍然是10，它不会被外界改变。
但是如果我们用__block来修饰int a，也就是 __block int a = 10, 最终a的值就是20，它被外界改变了，__block帮我们解决问题。
但是Why? block内部是以什么形式存在，并捕获值的呢？接下来我们要一探究竟。
准备工作:clang命令
大家可以用clang(或者gcc) -rewrite-objc xxxxx.m命令来查看转化成的c++代码来了解内幕。如果你引用了UIKIt库，这个命令会报错，那个因为命令里没有指定sdk的版本，此时用下面的命令完美解决：
clang -x objective-c -rewrite-objc -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator.sdk ViewController.m
__block的奥秘
不带__block的转化cpp代码：
int a = 10;
((void (*)(id, SEL, void (*)()))(void *)objc_msgSend)((id)(*(Foo **)((char *)self + OBJC_IVAR_$_ViewController$_foo)), sel_registerName("setTestBlock:"), ((void (*)())&__ViewController__viewDidLoad_block_impl_0((void *)__ViewController__viewDidLoad_block_func_0, &__ViewController__viewDidLoad_block_desc_0_DATA, self, a, 570425344)));
a+= 10;
((void (*(*)(id, SEL))())(void *)objc_msgSend)((id)(*(Foo **)((char *)self + OBJC_IVAR_$_ViewController$_foo)), sel_registerName("testBlock"))();
带__block转化代码：
__attribute__((__blocks__(byref))) __Block_byref_a_0 a = {(void*)0,(__Block_byref_a_0 *)&a, 0, sizeof(__Block_byref_a_0), 10};//对a的封装进行初始化
((void (*)(id, SEL, void (*)()))(void *)objc_msgSend)((id)(*(Foo **)((char *)self + OBJC_IVAR_$_ViewController$_foo)), sel_registerName("setTestBlock:"), ((void (*)())&__ViewController__viewDidLoad_block_impl_0((void *)__ViewController__viewDidLoad_block_func_0, &__ViewController__viewDidLoad_block_desc_0_DATA, self, (__Block_byref_a_0 *)&a, 570425344)));
(a.__forwarding->a)+= 10;
((void (*(*)(id, SEL))())(void *)objc_msgSend)((id)(*(Foo **)((char *)self + OBJC_IVAR_$_ViewController$_foo)), sel_registerName("testBlock"))();
__Block_byref_a_0的定义如下：
struct __Block_byref_a_0 {
void *__isa;
__Block_byref_a_0 *__forwarding;
int __flags;
int __size;
int a;//---->它就是传递进来的a
};
我们发现编译器把int a封装成了一个叫__Block_byref_a_0的结构体，最终用&符号将它的地址传递给了block，所以后面a被修改时，block里面的a也被同时修改。__block的奥秘就是这个！
Block的存在形式
object-c的Block最终以转化成多个了结构体，每个结构体都不同的职责。
__ViewController__viewDidLoad_block_impl_0 包含了block相关的所有信息的
基本构造是：
- impl
- desc
- 引用变量列表：ivar1, ivar2, ivar...
struct __ViewController__viewDidLoad_block_impl_0 {
struct __block_impl impl;//block的一个简化类，它里面存储了函数指针
struct __ViewController__viewDidLoad_block_desc_0* Desc;//block的描述类
ViewController *self;//被引用的viewcontroller
__Block_byref_a_0 *a; // 被引用的a的封装
__ViewController__viewDidLoad_block_impl_0(void *fp, struct __ViewController__viewDidLoad_block_desc_0 *desc, ViewController *_self, __Block_byref_a_0 *_a, int flags=0) : self(_self), a(_a->__forwarding) {//构造函数
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
__block_impl定义如下，很像一个类，里面有isa指针和block的函数指针，所以我们可以把它当作一个类
struct __block_impl {
void *isa;
int Flags;
int Reserved;
void *FuncPtr;
};
我们可以发现__ViewController__viewDidLoad_block_impl_0结构体的第一个参数是__block_impl，所以这两个结构体实例的地址是相同的。那到底oc的block是谁呢？我们一般会认为oc的block就是__block_impl，因为它正好有isa,可以作为一个类，这样大家都容易理解。
Block的三个子类
1.我们可以打印一个block的类及父类的名字：(这段代码摘自facebook的FBRetainCycleDetector)
static Class _BlockClass() {
static dispatch_once_t onceToken;
static Class blockClass;
dispatch_once(&onceToken, ^{
void (^testBlock)() = [^{} copy];
blockClass = [testBlock class];
while(class_getSuperclass(blockClass) && class_getSuperclass(blockClass) != [NSObject class]) {
blockClass = class_getSuperclass(blockClass);
}
[testBlock release];
});
return blockClass;
}
结果是__NSGlobalBlock -> NSBlock -> NSObject
事实上block有三种形式：
- __NSGlobalBlock 全局 （未捕获变量）
- __NSStackBlock 栈 捕获变量
- __NSMallocBlock 堆 捕获变量
在 ARC 中，捕获外部了变量的 block 的类会是 NSMallocBlock 或者 NSStackBlock，如果 block 被赋值给了某个变量在这个过程中会执行 _Block_copy 将原有的 NSStackBlock 变成 NSMallocBlock；但是如果 block 没有被赋值给某个变量，那它的类型就是 NSStackBlock；没有捕获外部变量的 block 的类会是 NSGlobalBlock 即不在堆上，也不在栈上，它类似 C 语言函数一样会在代码段中。
2.那什么时候在堆上，什么时候在栈上呢？
在ARC有效时，大多数情况下编译器会进行判断，自动生成将Block从栈上复制到堆上的代码，以下几种情况栈上的Block会自动复制到堆上：
- 调用Block的copy方法
- 将Block作为函数返回值时
- 将Block赋值给__strong修改的变量时
- 向Cocoa框架含有usingBlock的方法或者GCD的API传递Block参数时
3.block用strong修饰还是copy修饰呢？
实际上调用retain方法时, block会调用copy方法，所以这两种修饰是相同的。但是为了语义的明确，推荐用copy修饰。
获取block引用的对象
现在不讲源码，只讲实际应用。如何知道一个block对象，如何知道它持有的所有对象呢？facebook的FBRetainCycleDetector检测循环引用的库就实现这样的功能，非常的巧妙！我们就FBRetainCycleDetector的源码展出分析。
1.调用allRetainedObjects来获取：
- (NSSet *)allRetainedObjects
{
NSMutableArray *results = [[[super allRetainedObjects] allObjects] mutableCopy];
// Grab a strong reference to the object, otherwise it can crash while doing
// nasty stuff on deallocation
__attribute__((objc_precise_lifetime)) id anObject = self.object;//objc_precise_lifetime 翻译一下就是：精确生命周期，其实是强引用了object对象，防止在运行期间被释放
void *blockObjectReference = (__bridge void *)anObject;
NSArray *allRetainedReferences = FBGetBlockStrongReferences(blockObjectReference);//获得所有引用对象，就是下面要讲的方法
for (id object in allRetainedReferences) {
FBObjectiveCGraphElement *element = FBWrapObjectGraphElement(self, object, self.configuration);//对每个对象进行包装成box对象
if (element) {
[results addObject:element];
}
}
return [NSSet setWithArray:results];
}
2.FBGetBlockStrongReferences方法通过调用_GetBlockStrongLayout（block）方法返回的持有对象的位置Index, 然后通过偏移量来取得对应的对象：
NSArray *FBGetBlockStrongReferences(void *block) {
if (!FBObjectIsBlock(block)) {//是否是block类型
return nil;
}
NSMutableArray *results = [NSMutableArray new];
void **blockReference = block;
NSIndexSet *strongLayout = _GetBlockStrongLayout(block);//得到block里强引用的对象
[strongLayout enumerateIndexesUsingBlock:^(NSUInteger idx, BOOL *stop) {
void **reference = &blockReference[idx];//把它当作了一个链表来取值，它本是block结构体，正好它的align对齐字节大小是void*类型大小。怪不得blockReference要用void **来修饰，要以把它当作(void *)*blockReference,所以blockReference是一个指向(void *)的指针。
if (reference && (*reference)) {
id object = (id)(*reference);
if (object) {
[results addObject:object];
}
}
}];
return [results autorelease];
}
我写了一个demo, block里引用了viewcontroller, 但是viewController的idx是4，为什么呢？我们打印了blockLiteral结构体及成员变量的地址：
struct BlockLiteral {
void *isa; //0x00000001702493f0 占8个字节
int flags;//0x00000001702493f8 占4个字节
int reserved;//0x00000001702493fc 占4个字节
void (*invoke)(void *, ...);//0x0000000170249400 占8个字节
struct BlockDescriptor *descriptor;//0x0000000170249408 占8个字节
// imported variables
};
所有指针类型全是占8个字节，int类型占4个字节，所以flags+reserved加起来是相当于一个指针类型，不管怎么说，BlockLiteral的大小是固定的，它的对齐字节是8，它的大小正好是sizeof(void)的整数倍。这也解释了为什么定义了void **blockReference = block;,它把blockReference定义成了指向(void)的指针！（这里写的有点啰唆，实际上void*是最长的字节8，因为Int类型字节长只有4，所以是以void*作为进行字节对齐的）
3._GetBlockStrongLayout是整个过程最关键，也是最巧妙的地方:
static NSIndexSet *_GetBlockStrongLayout(void *block) {
struct BlockLiteral *blockLiteral = block;
/**
BLOCK_HAS_CTOR - Block has a C++ constructor/destructor, which gives us a good chance it retains
objects that are not pointer aligned, so omit them.
!BLOCK_HAS_COPY_DISPOSE - Block doesn't have a dispose function, so it does not retain objects and
we are not able to blackbox it.
*/
if ((blockLiteral->flags & BLOCK_HAS_CTOR)
|| !(blockLiteral->flags & BLOCK_HAS_COPY_DISPOSE)) {
return nil;
}
void (*dispose_helper)(void *src) = blockLiteral->descriptor->dispose_helper;
const size_t ptrSize = sizeof(void *);
// Figure out the number of pointers it takes to fill out the object, rounding up.
const size_t elements = (blockLiteral->descriptor->size + ptrSize - 1) / ptrSize;
// Create a fake object of the appropriate length.
void *obj[elements];
void *detectors[elements];
for (size_t i = 0; i < elements; ++i) {
FBBlockStrongRelationDetector *detector = [FBBlockStrongRelationDetector new];
obj[i] = detectors[i] = detector;
}
@autoreleasepool {
dispose_helper(obj);
}
// Run through the release detectors and add each one that got released to the object's
// strong ivar layout.
NSMutableIndexSet *layout = [NSMutableIndexSet indexSet];
for (size_t i = 0; i < elements; ++i) {
FBBlockStrongRelationDetector *detector = (FBBlockStrongRelationDetector *)(detectors[i]);
if (detector.isStrong) {
[layout addIndex:i];
}
// Destroy detectors
[detector trueRelease];
}
return layout;
}
重写了FBBlockStrongRelationDetector类的release方法：
- (oneway void)release
{
_strong = YES;
}
这个过程是：
- 获取销毁函数dispose_helper的函数指针
- 通过descriptor->size计算出block里成员变量个数（上面我们说过它把两个int算作了一个void*, 所以成员变量的个数实际上少了1个）
- 创建两个相同个数的fake数组obj，detectors，然后通过dispose_helper来只释放obj数组，dispose_helper会向调用每个对象的release方法, 而它又重写了release方法，在release时作了标记，通过这个标记就可以判断是为是引用的对象。它其实是欺骗了dispose_helper函数，因为它只认位置Index, 并不关心数组存储的是什么...
不得不赞叹fb的源码的深度和创新~
结语
还是那句话：源码下面无秘密。
苹果底层对于block实现真是煞费苦心。我们了解了原理，用起来会更加得深应手。
