在Block随记<一>中的例子Block捕获的都是基本数据类型，若Block捕获的是一个对象，情况就有些许不同...
共识1
示例代码：
#import "ALExplorer.h"
int main(int argc, const char * argv[]) {
@autoreleasepool {
/// 机遇号
ALExplorer *opportunity = [[ALExplorer alloc] initWithName:@""];
/// 勇气号
__block ALExplorer *spirit = nil;
void (^alBlock)(void) = ^{
opportunity.name = @"机遇号探测器";/// 值捕获
spirit = [[ALExplorer alloc] initWithName:@"勇气号探测器"];/// 引用捕获
};
alBlock();
NSString *str1 = opportunity.name;
NSString *str2 = spirit.name;
}
return 0;
}
opportunity是一个指针：它本身在栈上，占据8个字节(64位)，存储的值是堆上对象的首地址。如图所示：opportunity变量的地址是0x00007ffeefbff4e8，该地址存储的值是0x00000001006645d0，这个值是堆空间中的opportunity对象的地址。
共识2
ARC下当一个对象赋值给一个__strong类型的指针时它的引用计数会+1，也就是该指针“拥有”该对象。当__strong类型的指针指向别的对象后，之前的对象引用计数会-1。当复制给__weak、__unsafe_unretained类型的指针时它的引用计数不会改变。
捕获对象的指针
修改一下编译的命令指明使用ARCclang -rewrite-objc -fobjc-arc main.m，文章开始时候的示例代码编译后得到的源码也相对多一些，但大多和我们猜想的一致：
/// spirit指针采用引用捕获，这是被封装的结构体。spirit指针 -> spirit结构体
struct __Block_byref_spirit_0 {
void *__isa; /// 8字节
__Block_byref_spirit_0 *__forwarding; /// 8字节
int __flags; /// 4字节
int __size; /// 4字节
/// 处理spirit结构体对应的堆中对象，参数131
void (*__Block_byref_id_object_copy)(void*, void*); /// 8字节
void (*__Block_byref_id_object_dispose)(void*); /// 8字节
/// 指向“堆中的spirit对象”
ALExplorer *__strong spirit;
};
/// Block定义
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
ALExplorer *__strong opportunity; /// opportunity指针采用值捕获
__Block_byref_spirit_0 *spirit; // by ref /// 指向“spirit结构体”
/// 结构体构造函数
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, ALExplorer *__strong _opportunity, __Block_byref_spirit_0 *_spirit, int flags=0) : opportunity(_opportunity), spirit(_spirit->__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_spirit_0 *spirit = __cself->spirit; // bound by ref
ALExplorer *__strong opportunity = __cself->opportunity; // bound by copy
/// 使用objc_msgSend调用opportunity对象的stter方法给其name属性赋值
objc_msgSend(opportunity, sel_registerName("setName:"), &__NSConstantStringImpl__var_folders_8f_c7chq5p16z54819ns4hxvgwm0000gp_T_main_369368_mi_1);
/// 两次使用objc_msgSend创建并初始化一个对象，然后“spirit结构体”的成员赋值
spirit->__forwarding->spirit = objc_msgSend(objc_msgSend(objc_getClass("ALExplorer"), sel_registerName("alloc")), sel_registerName("initWithName:"), &__NSConstantStringImpl__var_folders_8f_c7chq5p16z54819ns4hxvgwm0000gp_T_main_369368_mi_2);
}
/// Block被拷贝时对捕获值的操作
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {
/// 处理opportunity指针，参数3
_Block_object_assign((void*)&dst->opportunity, (void*)src->opportunity, 3/*BLOCK_FIELD_IS_OBJECT*/);
/// 处理spirit结构体，参数8
_Block_object_assign((void*)&dst->spirit, (void*)src->spirit, 8/*BLOCK_FIELD_IS_BYREF*/);}
/// Block释放时对捕获值的操作
static void __main_block_dispose_0(struct __main_block_impl_0*src) {
_Block_object_dispose((void*)src->opportunity, 3/*BLOCK_FIELD_IS_OBJECT*/);
_Block_object_dispose((void*)src->spirit, 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[]) {
ALExplorer *opportunity = objc_msgSend(objc_msgSend(objc_getClass("ALExplorer"), sel_registerName("alloc")), sel_registerName("initWithName:"), &__NSConstantStringImpl__var_folders_8f_c7chq5p16z54819ns4hxvgwm0000gp_T_main_369368_mi_0);
/// spirit结构体
__Block_byref_spirit_0 spirit = {
0,
&spirit,
33554432,
sizeof(__Block_byref_spirit_0),
__Block_byref_id_object_copy_131,
__Block_byref_id_object_dispose_131,
__null
};
void (*alBlock)(void) = &__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA, opportunity, &spirit, 570425344);
(alBlock->FuncPtr)(alBlock);
NSString *str1 = objc_msgSend(opportunity, sel_registerName("name"));
NSString *str2 = objc_msgSend(spirit.__forwarding->spirit, sel_registerName("name"));
return 0;
}
先上图：
说明：
- 原始的opportunity和spirit都是栈上的指针，它们都指向堆中的对象；
- spirit被封装后变成栈上的结构体；
- 在Block外部访问方式是
spirit.__forwarding->spirit； - 在Block内部变成
spirit->__forwarding->spirit，因为创建Block结构体时传递的是&spirit；
- 图中浅黑色部分表示堆中对象；
- 值捕获opportunity后有两个指针指向堆中对象，且它们脱离了联系；引用捕获只有一个指针指向堆中对象；
Block拷贝到堆上时的调用链
处理opportunity对象
(1) _Block_copy(alBlock)
(2) _Block_copy_internal(alBlock, 570425344)Block复制完成
(3) __main_block_copy_0(copiedBlock, alBlock)开始处理Block捕获的值
(4) _Block_object_assign(&(copiedBlock->opportunity), alBlock-> opportunity, 3)
(5.1) _Block_retain_object(aBlock->opportunity)
(5.2) _Block_assign(alBlock->opportunity, &(copiedBlock->opportunity))
处理spirit对象
spirit结构体内部声明了__Block_byref_id_object_copy和__Block_byref_id_object_dispose两个函数指针，在创建alBlock结构体时它们分别被赋值为__Block_byref_id_object_copy_131()和__Block_byref_id_object_dispose_131()。
(1) _Block_copy(alBlock)
(2) _Block_copy_internal(alBlock, 570425344)Block复制完成
(3) __main_block_copy_0(copiedBlock, alBlock)开始复制Block捕获的结构体
(4) _Block_object_assign(&(copiedBlock->spirit), alBlock->spirit, 8)
(5) _Block_byref_assign_copy(&(copiedBlock->spirit), alBlock->spirit, 8)Block捕获的结构体复制完成
(6) (*src->byref_keep)(copiedByref, srcByref);开始操作堆上的对象
(7) __Block_byref_id_object_copy_131(copiedByref, srcByref, 131)
(8) _Block_object_assign(copiedByref+40, *(srcByref+40), 131)
(8) _Block_assign(*(srcByref+40), copiedByref+40)堆上的对象赋值给堆上结构体中的指针
两次调用_Block_object_assign()，实际上第一次是处理spirit结构体，第二次是处理spirit对象。传入不同的flags，方法内会执行了不同的操作：
void _Block_object_assign(void *destAddr, const void object, const int flags) {
//printf("_Block_object_assign(%p, %p, %x)\n", destAddr, object, flags);
if ((flags & BLOCK_BYREF_CALLER) == BLOCK_BYREF_CALLER) {/// 128、131走该分支
if ((flags & BLOCK_FIELD_IS_WEAK) == BLOCK_FIELD_IS_WEAK) {
_Block_assign_weak(object, destAddr);
}
else {
// do not retain or copy __block variables whatever they are
_Block_assign((void *)object, destAddr);
}
}
else if ((flags & BLOCK_FIELD_IS_BYREF) == BLOCK_FIELD_IS_BYREF) {/// 8
// copying a __block reference from the stack Block to the heap
// flags will indicate if it holds a __weak reference and needs a special isa
/// 源码在Block随记<一>中，里面会调用(*src->byref_keep)(copiedByref, srcByref)
_Block_byref_assign_copy(destAddr, object, flags);
}
// (this test must be before next one)
else if ((flags & BLOCK_FIELD_IS_BLOCK) == BLOCK_FIELD_IS_BLOCK) {
// copying a Block declared variable from the stack Block to the heap
_Block_assign(_Block_copy_internal(object, flags), destAddr);
}
// (this test must be after previous one)
else if ((flags & BLOCK_FIELD_IS_OBJECT) == BLOCK_FIELD_IS_OBJECT) {/// 3
//printf("retaining object at %p\n", object);
_Block_retain_object(object);
//printf("done retaining object at %p\n", object);
_Block_assign((void *)object, destAddr);
}
}
从代码的注释也可以看出spirit对象的引用计数不会增加(MRC下很好验证，见下面的实例4)，只是把堆上spirit结构体的spirit指针指向了堆上的spirit对象(有点绕～)。
拷贝完成后，指向opportunity对象的指针有两个创建对象是的opportunity指针和alBlock内部通过值捕获得到的指针，而指向spirit对象的指针是一个spirit结构体中的spirit指针。
值捕获的几个例子
修改ALExplorer类兼容MRC和ARC：
/// .h
@interface ALExplorer : NSObject
@property (nonatomic, copy) NSString *name;
- (instancetype)initWithName:(NSString * _Nullable)name;
@end
/// .m
#import "ALExplorer.h"
@implementation ALExplorer
- (instancetype)initWithName:(NSString *)name {
self = [super init];
if (self) {
_name = [name copy];
}
return self;
}
- (void)setName:(NSString *)name {
#if __has_feature(objc_arc)
#else
[_name release];
#endif
_name = [name copy];;
}
- (void)dealloc {
printf("Dealloc ALExplorer!!!\n");
#if __has_feature(objc_arc)
#else
[_name release];/// 和-initWithName:中的[name copy]对应
[super dealloc];
#endif
}
@end
例1：stackBlock不会引起捕获对象的引用计数增加
例2：mallocBlock会引起捕获对象的引用计数增加
例3：__weak不会引起捕获对象的引用计数增加
引用捕获的几个例子
例4：__block确实不会引起捕获对象的引用计数增加
无论Block是否被拷贝到堆上，MRC下
__block确实不会引起捕获对象的引用计数增加。spirit对象释放后，alBlock内部试图通过spirit指针访问它就造成了异常（__block变成了一个危险的东西）。此时有两种方法解决：
- 在alBlock内部给spirit指针重新赋值一个堆上的对象，这也正是使用
__block的真正目的所在； - 定义一个
__weak指针指向spirit对象，让alBlock捕获这个弱引用的指针：__weak ALExplorer *weakSpirit = spirit。
例5：ARC下系统会帮我们自动处理上例中的情况
循环引用
从上面几节可以看出，MRC下的值捕获，ARC下的值捕获和引用捕获都可能产生循环引用。二打破循环引用就需要用到__weak。
参考：
1
2
3