这是 Objective-C 高级编程 第二章。这一章的内容，囧，太底层了，还是要把知识往实际上靠。下周就是最后一章，就看完它了，应该过不久又要学 Swift 了，囧囧囧囧_
一些测试代码
栈上 Block 对象捕获强引用和弱引用变量：
NSObject *a = [NSObject new];
NSObject * __weak b = a;
NSLog(@"%@ %lu", ^{
a;
}, _objc_rootRetainCount(a));
// 输出：<__NSStackBlock__: 0x7fff5fbff7c0> 2
NSLog(@"%@ %lu", ^{
b;
}, _objc_rootRetainCount(a));
// 输出：<__NSStackBlock__: 0x7fff5fbff7f8> 2
NSLog(@"%@ %lu", ^{
a;
}, _objc_rootRetainCount(a));
// 输出：<__NSStackBlock__: 0x7fff5fbff798> 3
栈上和堆上对 __strong 变量的捕获，以及堆上 Block 调用 copy：
NSObject *obj = [NSObject new]; // 引用计数为 1
NSLog(@"%@ %lu", ^{ NSLog(@"blk0: %@", obj); }, _objc_rootRetainCount(obj));
// 输出：<__NSStackBlock__: 0x7fff5048aac0> 2，因为被 Stack Block 持有
id a = ^{ NSLog(@"blk1: %@", obj); };
NSLog(@"%lu", _objc_rootRetainCount(obj));
// 输出：4。因为赋值时，将 Block 复制到堆上，就有了两个 Block 对象持有 obj。
id b = [a copy];
NSLog(@"%lu", _objc_rootRetainCount(obj));
// 输出：4。已经在堆上的 Block 再调用 copy 不会对 obj 有影响，可能在 Block 上后再调用 copy 不会做任何事。
栈上和堆上对 __block 对象的变量的持有情况：
void (^blk)() = nil;
{
__block NSMutableArray * __strong a = [NSMutableArray new];
__block NSMutableArray * __strong b = a;
NSLog(@"%lu", _objc_rootRetainCount(b)); // 输出：2
blk = ^{
[a addObject:[NSObject new]];
NSLog(@"%p %@ %lu", a, a, _objc_rootRetainCount(a));
// 输出：0x7f8064318a80 ("<NSObject: 0x7f8064006490>") 1
};
NSLog(@"%p %@ %lu", a, a, _objc_rootRetainCount(a));
// 输出：0x7f8064318a80 () 2
// 这里如果按上一个解释的话应该输出 4 才对，栈和堆各持有一次，实际上不是
}
blk();
// 这里的解释是：1. Block 栈对象是直接持有的 __block a 对象的指针，所以不会对 array a 对象持有引用。
// 2. 当 Block 从栈复制到堆时，
// 若 Block 使用的变量为附有 __block 说明符的 id 类型或对象类型的自动变量，不会被 retain；
// 若 Block 使用的变量为没有 __block 说明符的 id 类型或对象类型的自动变量，则被 retain 。
上一份测试代码的补充：
// 上面代码不会 crash，但是 blk() 里的 array 确实已经是野指针了。
NSMutableArray * __unsafe_unretained c;
{
NSMutableArray * __strong a = [NSMutableArray new];
c = a;
}
[c addObject:[NSObject new]];
// c 是野指针，也不会 crash 。<这要看运气咯>
id __strong array = __cself->array 并不会 retain。
void (^blk)(id) = nil;
{
id array = [[NSMutableArray alloc] init];
blk = [^(id obj) {
[array addObject:obj];
NSLog(@"%ld %lu", [array count], _objc_rootRetainCount(array)); // 输出：1 1
// 在 ARC 中是不允许在结构体中使用 Objective-C 对象的，所以这里总有些不合逻辑的地方。
// 在 Block 实现的函数中，最开始就有语句：id __strong array = __cself->array;
// 按理应该会再持有一次 array 的，但是 array 的引用计数没有变。
// 仍然只是 Block 对象的成员变量持有的一次 array。
} copy];
}
blk([NSObject new]);
截获自动变量
int main(int argc, char * argv[]) {
@autoreleasepool {
int dmy = 256;
int val = 10;
const char *fmt = "val = %d";
NSObject *a = [NSObject new];
NSObject __weak *b = a;
void (^blk)() = ^{
printf(fmt, val);
b; // 测试弱引用
};
blk();
}
return 0;
}
Console 使用 clang -rewrite-objc main.m 转换为下面 C语言代码（并不难看懂）：
struct __block_impl {
void *isa; // _NSConcreteStackBlock、_NSConcreteGlobalBlock、_NSConcreteMallocBlock
int Flags; // 标志位
int Reserved; // 版本升级可能用到的保留位
void *FuncPtr; // Block 函数
};
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
const char *fmt;
int val;
NSObject *__weak b;
// 构造函数
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, const char *_fmt, int _val, NSObject *__weak _b, int flags=0) : fmt(_fmt), val(_val), b(_b) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
const char *fmt = __cself->fmt; // bound by copy
int val = __cself->val; // bound by copy
NSObject *__weak b = __cself->b; // bound by copy
printf(fmt, val);
b;
}
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->b, (void*)src->b, 3/*BLOCK_FIELD_IS_OBJECT*/);}
static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->b, 3/*BLOCK_FIELD_IS_OBJECT*/);}
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, char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
int dmy = 256;
int val = 10;
const char *fmt = "val = %d";
NSObject *a = ((NSObject *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("NSObject"), sel_registerName("new"));
NSObject __attribute__((objc_gc(weak))) *b = a;
void (*blk)() = (void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, fmt, val, b, 570425344);
((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
}
return 0;
}
从 main 函数看到，Block 实际上被转换成了位于栈上的 __main_block_impl_0 自动变量。__main_block_copy_0 中的 _Block_object_assign 函数相当于 retain 实例方法，使 Block 的成员变量 b 持有捕获到的对象。 __main_block_dispose_0 中的 _Block_object_dispose 函数相当于 release 实例方法，释放 Block 的成员变量 b 持有的对象。
Block 不能捕获数组的原因是：在 __main_block_fun_0() 中需要对捕获到的变量赋值，而 C语言不支持数组赋值。
int a[20];
int b[20] = a; // 编译错误
截获的自动变量不能在 Block 中赋值，产生编译错误。因为就算改变 Block 中该变量的值也不能改变 Block 外部变量的值，既然如此，编译器就不让你改了，但可以在 Block 中再声明一个变量，然后去修改这个新的变量。但对于
静态全局变量（static） 和全局变量，因为它们本身就可以被全局访问，所以 Block 不会捕获它们，且可以在 Block 中修改它们的值；对于静态局部变量因为它不能被全局访问，当截获它时会自动截获它的地址作为 Block 的成员变量，也可以在 Block 中修改它们的值。为什么不对所有变量都保存指针呢？因为不安全，局部变量在作用域结束就会被释放，但 Block 仍然保留着它的地址，就形成野指针了。
__block storage-class-specifier
__block 类似于 static auto register 说明符，它们用于指定将变量设置到那个存储域中。
int main(int argc, char * argv[]) {
@autoreleasepool {
__block int val = 10;
void (^blk)(void) = ^{ val = 1; };
}
return 0;
}
Console 使用 clang -rewrite-objc main.m 转换为下面 C语言代码：
// 声明为 __block 的变量会被转换成该类型的结构体
struct __Block_byref_val_0 {
void *__isa;
__Block_byref_val_0 *__forwarding;
int __flags;
int __size;
int val; // __block 原自动变量
};
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
__Block_byref_val_0 *val; // by ref
// 构造函数
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_val_0 *_val, int flags=0) : val(_val->__forwarding) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
// Block 函数体
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
__Block_byref_val_0 *val = __cself->val; // bound by ref
(val->__forwarding->val) = 1;
}
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src)
{_Block_object_assign((void*)&dst->val, (void*)src->val, 8/*BLOCK_FIELD_IS_BYREF*/);}
static void __main_block_dispose_0(struct __main_block_impl_0*src)
{_Block_object_dispose((void*)src->val, 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, char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
__attribute__((__blocks__(byref))) __Block_byref_val_0 val = {(void*)0,(__Block_byref_val_0 *)&val, 0, sizeof(__Block_byref_val_0), 10};
void (*blk)(void) = (void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_val_0 *)&val, 570425344);
}
return 0;
}
从转换后的代码中可以看到 __block 指定的变量被转换成了 __Block_byref_val_0 结构体，并且在 __main_block_impl_0 中以前捕获自动变量的位置被替换成了对应的 __Block_byref_val_0 指针。__main_block_impl_0 中 __block_impl 成员的 isa 指针一般为 _NSConcreteStackBlock，但当满足以下任一情况时，Block 将被指定为：_NSConcreteGlobalBlock 类对象。
- 在全局变量的地方使用 Block
- Block 的表达式中没有截获自动变量
配置在全局变量上的 Block，从变量作用域外也可以通过指针安全访问（全局变量作用域好大的）。但设置在栈上的 Block，如果其所属的变量作用域结束，该 Block 就被废弃。由于 __block 变量也配置在栈上，同样地，如果其所属的变量作用域结束，该 Block 就被废弃。
实际上当 ARC 有效时，大多数情况下编译器会恰当地进行判断，自动生成 Block 从栈上复制到堆上的代码。只有在 向方法或函数的参数中传递 Block 时 需要手动生成代码。但是在函数或方法中适当地复制了传递过来的参数，那么就不必调用 copy 方法手动复制了。以下方法或函数不用手动复制：
- Cocoa 框架的方法且方法名中含有 usingBlock 等
- Grand Central Dispatch 的 API
举个例子，以下是会 crash 的代码（我是在 ViewController 中测试的）
- (id) getBlockArray {
int val = 10;
NSArray *arr = [[NSArray alloc] initWithObjects:
^{NSLog(@"blk0: %d", val); },
^{NSLog(@"blk1: %d", val); },
nil];
// initWithObjects 没有将 Block 从栈上 copy 到堆上，在函数结束时，它们就随着栈一起被释放了
return arr;
}
- (void)viewDidLoad {
[super viewDidLoad];
NSArray *arr = [self getBlockArray];
void (^blk)() = [arr objectAtIndex:0];
blk(); // Block 对象已经被释放，将 crash
}
但是下面的代码不会 crash
- (void)viewDidLoad {
[super viewDidLoad];
int val = 10;
NSArray *arr = [[NSArray alloc] initWithObjects:
^{NSLog(@"blk0: %d", val); },
^{NSLog(@"blk1: %d", val); },
nil];
// NSLog(@"%@", [arr objectAtIndex:0]); // => 输出：<__NSMallocBlock__: 0x7fed53f276e0>
((void (^)())[arr objectAtIndex:0])(); // 不会 crash
// 在 ARC 有效时，如果函数（上面的 objectAtIndex）返回的是 Block 则会被自动 copy 到堆中。
// 还有，在 ARC 有效时，向 id 或 Block 变量赋值时也会自动将 Block 从栈 copy 到堆中。
}
Block 对象使用 copy 方法的效果总结：
| Block 的类 | 副本源的存储位置 | 赋值效果 |
|---|---|---|
| _NSConcreteStackBlock | 栈 | 从栈赋值到堆 |
| _NSConcreteStackBlock | 程序数据区 | 什么也不做 |
| _NSConcreteStackBlock | 堆 | 什么也不做 |
Note: 但是 Block 对象的引用计数永远是 1，有可能没有加入引用计数表，也可能堆上的 Block 做 copy 时什么也没做。
当 Block 从栈复制到堆时对 __block 变量的影响：
| __block 变量的存储区 | 副本源的存储位置 |
|---|---|
| 栈 | 从栈赋值到堆并被 Block 持有 |
| 堆 | 被 Block 持有 |
Note：__block 变量实际上是 Objective-C 对象。 我们在程序中不能访问
__block对象，因为源代码都会被转换成 val->__forwarding->val 。
到此，可以说明 __block 结构体的成员变量 __forwarding 的作用了——不管 __block 变量配置在栈上还是堆上，都能正确地访问到该变量。代码如下：
__block int val = 0; // val 变量在栈上
void (^blk)(void) = [^{val++;} copy];
// blk 变量在堆上了（__block 变量也被 copy 到堆上），val->__forwarding 指向堆上的 __block 对象
++val; // ++(val->__forwarding->val)
blk(); // ++(val->__forwarding->val) 它的 val 在堆上，__forwarding 指向自己
NSLog(@"%d", val); // 输出为2
循环引用
typedef void(^blk_t)(void);
@interface MyObject : NSObject {
blk_t blk_;
id obj_;
}
@end
@implementation MyObject {
-(id)init{
self = [super init];
blk_ = ^{ NSLog(@"obj_ = %@", obj_); }
// 发生循环引用，因为 Block 捕获到的对象实际上是 self，即 obj_ 被编译为 self->obj_
// 使用 id __weak obj = obj_; 避免循环引用
return self;
}
}
通过使用 __block 变量可以避免循环引用，在非 ARC 时候经常被这样用，好吧，其实我并不想管非 ARC 是什么情况，只是它真的可以避免循环引用。
typedef void(^blk_t)(void);
@interface MyObject : NSObject {
blk_t blk_;
}
@end
@implementation MyObject {
-(id)init{
self = [super init];
__block MyObject * tmp = self; // 使用 __block 变量避免循环应用，这里 self 的引用计数加 1
blk_ = ^{ NSLog(@"self = %@", tmp); }
// blk_ 持有了含有 self 的 __block 变量；self 又持有了 blk_ 循环引用了。继续看下面~
return self;
} // __block 无论是在堆上还是在栈上都不会持有 val->forwarding->val 的对象。
// tmp 在栈上且超出作用域，即被销毁。现在 blk_ 仍然持有 tmp 对应的堆上 __block 对象，
// 但堆上的 __block 对象并不持有 self，即不再是循环引用
}
