block是如何捕获对象类型的数据
在ARC环境下,我们先创建一个MJPerson类,再重写Person类的dealloc方法
MJPerson.h
#import <Foundation/Foundation.h>
@interface MJPerson : NSObject
@property (assign, nonatomic) int age;
@end
MJPerson.m
#import "MJPerson.h"
@implementation MJPerson
- (void)dealloc
{
NSLog(@"MJPerson - dealloc");
}
@end
Main
int main(int argc, const char * argv[]) {
@autoreleasepool {
MJBlock block;
{
MJPerson *person = [[MJPerson alloc] init];
person.age = 10;
}
NSLog(@"------");
}
return 0;
}
RUN>
*********************** 运行结果 ************************** 2021-04-24 16:20:03.011922+0800 Interview01-block的copy[2934:145479] MJPerson - dealloc 2021-04-24 16:20:03.012458+0800 Interview01-block的copy[2934:145479] ------image-20210424162328845当我们的代码走到断点的时候,
Person被销毁了,这很容易理解,因为出了person变量的作用域。
ARC环境-->堆上的block-->强指针MJPerson *person
int main(int argc, const char * argv[]) {
@autoreleasepool {
MJBlock block;
{
MJPerson *person = [[MJPerson alloc] init];
person.age = 10;
block = ^{
NSLog(@"---------%d", person.age);
};
}
NSLog(@"------");
}
return 0;
}
RUN>
image-20210424162544321现在是ARC环境，
block属于强指针，因此在将block对象赋值给block指针的时候，编译器会自动对block对象执行copy操作，因此赋值完成后，block指向的是一个堆空间上的block对象副本。我们在
block中使用了person,会发现代码再次走到断点的时候,person并没有释放,这是为什么呢?
我们看一下转换后的底层代码:
$ xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
MJPerson *person;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, MJPerson *_person, int flags=0) : person(_person) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
可以看出
__main_block_impl_0对MJPerson *person进行了捕获，int main(int argc, const char * argv[]) { /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; MJBlock block; { MJPerson *person = ((MJPerson *(*)(id, SEL))(void *)objc_msgSend)((id)((MJPerson *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("MJPerson"), sel_registerName("alloc")), sel_registerName("init")); ((void (*)(id, SEL, int))(void *)objc_msgSend)((id)person, sel_registerName("setAge:"), 10); block = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, person, 570425344)); } NSLog((NSString *)&__NSConstantStringImpl__var_folders_yh_qjzhl57s63j2m9l4frv27zjc0000gn_T_main_100a49_mi_1); } return 0; }
__main_block_impl_0构造函数，直接把MJPerson *person作为参数传入，block持有person对象的指针，所以当block对象没有释放的时候，person对象没有销毁。
int main(int argc, const char * argv[]) {
@autoreleasepool {
MJBlock block;
{
MJPerson *person = [[MJPerson alloc] init];
person.age = 10;
block = ^{
NSLog(@"---------%d", person.age);
};
NSLog(@"%@", [block class]);
NSLog(@"%@", [block superclass]);
}
NSLog(@"------");
}
return 0;
}
RUN>
*********************** 运行结果 ************************** 2021-04-24 16:35:06.777511+0800 Interview01-block的copy[3240:155662] __NSMallocBlock__ 2021-04-24 16:35:06.777948+0800 Interview01-block的copy[3240:155662] __NSMallocBlock 2021-04-24 16:35:22.448208+0800 Interview01-block的copy[3240:155662] ------ 2021-04-24 16:35:22.448389+0800 Interview01-block的copy[3240:155662] MJPerson - dealloc
block在ARC环境下的类型为__NSMallocBlock__我们先假设在block内部对MJPerson的捕获是强引用的,因为只有是强引用才能解释为什么person出了作用域后仍然没有销毁。
我们将 ARC 改成 MRC ,然后运行
MRC环境-->栈上的block-->强指针MJPerson *person
对比ARC环境和MRC环境，我们知道在ARC环境下，
block的类型为__NSMallocBlock__在MRC环境下block的类型为__NSStackBlock__而block的类型为__NSStackBlock__时候，person出了作用域后，自动释放了，说明block不会强引用外部变量。由此我们可以得出结论:栈内存中的block是不会强引用外部变量的
同样在 MRC 环境下,我们把刚才栈上的block进行copy操作:
MRC环境-->堆上的block-->强指针MJPerson *person
很明显,
Person没有释放,说明了在 MRC 环境下,堆空间上的block会对Person进行一次相当于retain操作,保住了Person的命.
结论:不管是 ARC 环境还是 MRC 环境,栈空间的block(__NSStackBlock__)是不会拥有外部对象的;堆空间的block(NSMallocBlock)会拥有外部对象,在 ARC 环境下就是强引用,在 MRC 环境下就是 retain.
typedef void (^MJBlock)(void);
int main(int argc, const char * argv[]) {
@autoreleasepool {
MJBlock block;
{
MJPerson *person = [[MJPerson alloc] init];
__weak MJPerson *weakPerson = person;
person.age = 10;
block = [^{
NSLog(@"---------%d", weakPerson.age);
}copy];
NSLog(@"%@", [block class]);
NSLog(@"%@", [block superclass]);
}
NSLog(@"------");
}
return 0;
}
ARC环境-->堆上的block-->弱指针__weak MJPerson *person
我们使用
__weak修饰person,会发现Person对象走到NSLog处时会释放掉,相信有很多人都使用过__weak关键字修饰block内部访问的局部变量来防止循环引用,但这是为什么呢?
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m
*********************** 运行结果 ************************** /var/folders/yh/qjzhl57s63j2m9l4frv27zjc0000gn/T/main-f3e91d.mi:29179:28: error: cannot create __weak reference because the current deployment target does not support weak references __attribute__((objc_ownership(weak))) MJPerson *weakPerson = person;这报错的大概意思是,不能创建弱引用!这是因为弱引用的技术是需要
runtime动态支持的,静态的编译代码是没办法转换的.解决办法就是告诉编译器当前环境是 ARC 环境并且指定运行时的版本即可.完整的命令行如下xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc -fobjc-arc -fobjc-runtime=ios-8.0.0 main.m
成功转换后的__main_block_impl_0代码如下:
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
MJPerson *__weak weakPerson;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, MJPerson *__weak _weakPerson, int flags=0) : weakPerson(_weakPerson) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
我们再把__weak去掉
ARC环境-->堆上的block-->强指针MJPerson *person
通过对比我们可以得出结论:block内部在访问外部的auto变量时,外部auto变量是以什么指针访问的(strong / weak),结构体内内部也是以什么指针访问.
__main_block_desc_0
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};
image-20210424173918307函数指针
copy，也就是__main_block_copy_0()，内部调用了_Block_object_assign()函数指针
dispose，也就是__main_block_dispose_0()，内部调用了_Block_object_dispose()我们知道之前我们了解的
__main_block_desc_0结构体中只有reserved和Block_size两个成员,现在又增加了copy,dispose两个函数指针,这两个函数指针有什么作用呢?注意:只有在访问对象类型的auto变量时才会生成copy dispose.我们可以看出,copy指针指向__main_block_copy_0函数,dispose指针指向__main_block_dispose_0函数.static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->person, (void*)src->person, 3/*BLOCK_FIELD_IS_OBJECT*/);} //第一个dst代表拷贝之前栈空间的block， //第二个src代表拷贝之后堆空间上的block。 static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->person, 3/*BLOCK_FIELD_IS_OBJECT*/);}
__main_block_copy_0
当栈空间的block在进行copy操作变成堆空间的block时,block内部会自动调用__main_block_copy_0函数在
__main_block_copy_0内部会调用_Block_object_assign函数,并且把person当做参数传递进去.而在_Block_object_assign函数内部,会根据auto变量的修饰符(__strong,__weak,__unretained)进行相应的操作,形成强引用(retain)或者弱引用
__main_block_dispose_0如果
block从堆中移除(block销毁)时,会调用block内部的dispose函数,dispose函数内部又会调用__main_block_dispose_0函数,__main_block_dispose_0函数会自动释放引用的auto变量(release)
__main_block_desc_0中的函数指针copy和dispose。实际上这两个函数指针分别是在block从栈空间拷贝到堆空间的时候，以及堆空间的block被释放的时候使用的。MRC里面是没有
__weak和__strong这两个东西的。ARC就是根据我们代码中的__weak/__strong标记，来自动进行一些内存管理相关的处理。
ARC环境-->栈上的block-->弱指针__weak MJPerson *person
typedef void (^MJBlock)(void);
int main(int argc, const char * argv[]) {
@autoreleasepool {
MJBlock block;
{
MJPerson *person = [[MJPerson alloc] init];
__weak MJPerson *weakPerson = person;
person.age = 10;
NSLog(@"%@", [^{
NSLog(@"---------%d", weakPerson.age);
} class]);
}
NSLog(@"------");
}
return 0;
}
结论:
当block内部访问了对象类型的auto变量时:
1:如果block是在栈上,将不会对auto变量产生强引用(不管是 MRC 或者 ARC)
2:如果block是在堆上,就说明block进行过copy操作,进行copy操作的block会自动调用block内部的__main_block_copy_0函数,__main_block_copy_0函数内部会根据auto变量的修饰符形成相应的强引用(retain)或者弱引用.
3:当block销毁时,block会自动调用内部的dispose函数,dispose函数会自动调用内部的__main_block_dispose_0释放引用的auto变量.
特别备注
本系列文章总结自MJ老师在腾讯课堂iOS底层原理班（下）/OC对象/关联对象/多线程/内存管理/性能优化，相关图片素材均取自课程中的课件。如有侵权，请联系我删除，谢谢！
