笔记-《Objective-C高级编程 iOS与OS X多线程和
第一章自动引用计数,第二章 block,第三章 GCD。
转换代码的命令:
clang -rewrite-objc -fobjc-arc -fobjc-runtime=macosx-10.7 Test.m
一、自动引用计数
ARC 全称是 automatic Reference counting,编译器自动加入内存管理代码,无需手动输入 retain 或 release 代码了。
1.2 内存管理、引用计数
1.2.1 概要
OC 的内存管理,也就是引用计数,可以用开关房间的灯来说明。对象的引用计数为 0,就会被废弃。
办公室的照明管理1.2.2 内存管理的思考方式
- 自己生成的对象,自己持有;
- 非自己生成的对象,自己也能持有;
- 不再需要持有对象时要释放;
- 非自己持有的对象不要释放。
解释一下:
自己生成并持有对象,是指调用 alloc、new、copy、mutableCopy 等开头驼峰命名的方法群创建对象,比如 allocMyObject;
非自己生成的对象,是指调用 非 alloc/new/copy/mutableCopy 方法群创建对象;
持有对象,是指调用 retain 方法,或自己生成的对象;
释放对象,是指调用 release 方法;
废弃对象,是指 dealloc 方法。
// 自己生成并持有对象
id obj = [NSObject new];
// 用完后。。。
// 释放自己持有的对象
[obj release];
// 非自己生成的对象,并不持有
NSArray *array = [NSArray array];
// 持有它
[array retain];
// 用完后。。。
// 释放它
[array release];
下面讲解如何实现创建对象的方法。两种情况,自己持有的、非自己持有的。
第一种,自己持有的,实现 allocMyObject 方法:
- (id)allocMyObject {
id obj = [[NSObject alloc] init];
return obj;
}
第二种,非自己持有的,实现 myObject 方法:
- (id)myObject {
id obj = [[NSObject alloc] init];
// 变成非自己持有,自己是指调用方
[obj autorelease];
return obj;
}
调用 autorelease 会把对象放入自动释放池,使得对象超出指定的生存范围也能正确释放,pool 释放的时候会自动对里面的对象调用 release 方法。像 NSMutableArray 的 array 类方法就是这样实现的。
自己总结何时需要调用 release:
- 调用 alloc、new、copy、mutableCopy 等开头驼峰命名的方法创建的对象,用完后要调用 release;
- 调用非 alloc/new/copy/mutableCopy 方法群获得的对象,使用前先 retain,用完后调用 release;
- 实现非 alloc/new/copy/mutableCopy 开头的方法,返回创建的对象前要调用 autorelease。
1.2.3 alloc/retain/release/dealloc 实现
alloc 或 retain 会让引用计数值加 1,release 会让引用计数值减 1。引用计数值为 0 时,对象会被废弃 dealloc。
苹果应该是采用散列表管理引用计数,key 是内存地址,值是引用计数。
NSDefaultMallocZone、NSZoneMalloc、NSZone 是为防止内存碎片化而引入的结构。对内存分配的区域进行多重化管理,根据使用对象的目的、大小分配内存,从而提高了内存管理的效率。但是现在已经不需要了,运行时系统对内存管理的效率更加高效。
可以参考 programming with arc release notes。
1.2.5 autorelease
ARC 不支持 NSAutoreleasePool,改用 @autoreleasepool。
// MRC
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
id obj = [[NSObject alloc] init];
[obj autorelease];
[pool drain];
NSRunLoop 每次循环都会生成和废弃 NSAutoreleasePool 对象,废弃释放池对象的时候也会废弃里面的对象。用于循环可以减小内存峰值,代码如下:
for (int i = 0; i < count; i++) {
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
id obj = [[NSObject alloc] init];
[obj autorelease];
[pool drain];
}
上面的代码,不用等到整个循环结束才废弃 autorelease 对象,可以减小内存峰值。
1.3 ARC 规则
1.3.3 所有权修饰符
4 个修饰符:
- __strong
- __weak
- __unsafe_unretained
- __autoreleasing
__strong、__weak、__autoreleasing 修饰的变量,会初始化为 nil。
__strong 修饰符
__strong 是默认的修饰符,这两句代码是等效的:
id __strong obj = [[NSObject alloc] init];
id obj = [[NSObject alloc] init];
__strong 是强引用,可以持有对象。
__strong 修饰的变量指向一个对象,可以使对象的引用数+1。变量超出作用域失效时,引用的对象会释放,如果对象的引用数为 0,就会废弃。
__weak 修饰符
__weak 是弱引用,不能使对象的引用数 +1,而且对象废弃后,变量会置 nil。用于解决循环引用。
id __weak obj = [[NSObject alloc] init];
上面的代码会警告:Assigning retained object to weak variable; object will be released after assignment。
alloc 后引用数应该是 1,编译器可能在赋值后加了一句 release,所以赋值给 weak 变量后,obj 会被废弃?(这里赋值后,编译器判断对象没有持有者,会通过插入 release 释放它。具体看 1.4.2 节。)
其实也不用想这么复杂,没有强引用指向它,所以就被废弃了。
__unsafe_unretained 修饰符
__weak 要求 iOS 5 以上,iOS5 之前用 __unsafe_unretained 代替。
__unsafe_unretained 修饰的变量,不属于编译器内存管理对象。
__unsafe_unretained 不能持有对象,对象废弃后不会置 nil,继续访问可能崩溃。
id __unsafe_unretained obj = [[NSObject alloc] init];
上面的代码会警告:Assigning retained object to unsafe_unretained variable; object will be released after assignment。
这里在赋值后,编译器判断对象没有持有者,会通过插入 release 释放它。
__autoreleasing修饰符
__autoreleasing 修饰的变量指向的对象相当于调用 autorelease,会注册到自动释放池。
在 ARC,__autoreleasing 代替 autorelease,@autoreleasepool 代替 NSAutoreleasePool:
// ARC 无效
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
id obj = [[NSObject alloc] init];
[obj autorelease];
[pool drain];
// ARC
@autoreleasepool {
id __autoreleasing obj = [[NSObject alloc] init];
// 如果使用的是 __strong,alloc 创建的对象不会放入释放池?
}
__autoreleasing 很少显式使用。在 @autoreleasepool 代码块里面,通过 alloc/new/copy/mutableCopy 以外的方法创建的对象,会注册到自动释放池。
@autoreleasepool {
// 不使用 __autoreleasing,也能使对象注册到自动释放池。
// 编译器判断方法名后,自动注册到自动释放池。
id __strong obj = [NSMutableArray array];
}
下面的代码,编译器也会自动注册到释放池:
+ (id)array {
id obj = [[NSMutableArray alloc] init];
return obj;
}
id obj 和 id __strong obj 是一样的,由于 return 使得对象超出作用域会被自动释放,所以编译器会自动将其注册到释放池。
虽然 __weak 是为了解决循环引用,但在访问 __weak 修饰的变量时,其实是访问自动释放池里的对象。
理由是 __weak 修饰的对象会随时废弃,__autoreleasing 确保在池子释放前可以访问该对象。具体后文会解释。代码如下所示:
// 其实是访问释放池里的对象
id __weak obj1 = obj0;
NSLog(@"class = %@", [obj1 class]);
// 和上面的代码段一样的
id __weak obj1 = obj0;
id __autoreleasing tmp = obj1;
NSLog(@"class = %@", [tmp class]);
还有一种非显式使用 __autoreleasing 的情况:
id 或对象的指针,默认是 __autoreleasing 修饰,比如 NSError **perror,和 NSError * __autoreleasing *perror 是一样的。
- (void)test1 {
NSError *error = nil; // &error 的类型是 'NSError *__strong *'
NSError * __strong *p3 = &error; // 编译通过
// p1 的类型是 'NSError *__autoreleasing *'。
// 编译报错,Pointer to non-const type 'NSError *' with no explicit ownership。
NSError **p1 = &error;
// 编译报错,Initializing 'NSError *__autoreleasing *' with an expression
// of type 'NSError *__strong *' changes retain/release properties of pointer
NSError * __autoreleasing *p2 = &error;
// 编译通过,但为何不报错呢,实参是 __strong,形参是 __autoreleasing。
// 编译通过,是因为编译器做了处理:
// NSError __autoreleasing *tmp = error;
// [self testError:&tmp];
// error = tmp;
[self testError:&error];
}
// perror 的类型是 'NSError *__autoreleasing *'
- (void)testError:(NSError **)perror {
*perror = [NSError errorWithDomain:@"" code:0 userInfo:nil];
}
上面 testError 的形参是 __autoreleasing 的,所以能够返回注册到释放池的对象。形参改用 __strong 修饰也能够返回对象,使用 __autoreleasing 是为了遵守内存管理的规则:使用 alloc/new/copy/mutableCopy 创建的对象是自己创建并持有,其他方法创建的是非自己创建并持有的对象,类似 NSMutableArray 的 array 方法。
另外,虽然可以非显式使用 __autoreleasing,如果显式使用的话,对象变量必须是自动变量(包括局部变量、函数参数)。
无论 ARC 是否有效,调试使用非公开函数 _objc_autoreleasePoolPrint() 可以查看注册到释放池上的对象。
1.3.4 规则
- 不能使用 retain/release/retainCount/autorelease
- 不能调用 dealloc
- 必须遵守内存管理的函数命名
- 对象不能作为 C语言结构体的成员
- 使用 __bridge 转换 'id' 和 'void *'
以 alloc/new/copy/mutableCopy 开头的函数返回的对象,必须是调用方持有的,这是 MRC 的规则,ARC 也要遵守。
ARC 还得加一条:init 开头的函数,必须是实例方法,必须返回对象,该对象并不注册到释放池,基本上只是对 alloc 创建的对象进行初始化。像 -(void)initTheObject 这样的命名不要使用,因为没有返回对象。
对象不能作为 C语言结构体的成员,我试了没有报错而且能运行。这条规则有点迷:
struct Data {
NSMutableArray *array;
};
ARC 显式转换 'id' 和 'void *',直接转会报错,应该使用 __bridge 转换:
- (void)testVoid {
id obj = [NSObject new];
// 报错,Implicit conversion of Objective-C pointer type 'id' to C pointer type 'void *' requires a bridged cast。
// Use __bridge to convert directly (no change in ownership)。
// Use CFBridgingRetain call to make an ARC object available as a +1 'void *'。
void *p = obj; // MRC 是可以的,不会报错。
// 使用 __bridge 转换
void *p = (__bridge void *)obj;
id obj2 = (__bridge id)p;
[obj2 description];
}
__bridge 转换还有两种:__bridge_retained、__bridge_transfer。
__bridge_retained 相当于转换后,再调用一次 retain,两者同时持有对象:
// ARC
id obj = [NSObject new];
void *p = (__bridge_retained void *)obj;
ARC 的代码相当于 MRC:
// MRC
id obj = [NSObject new];
void *p = obj;
[(id)p retain];
__bridge_transfer 相当于转换后,再调用一次 retain 和 release,旧变量不再持有对象:
// ARC
id obj = (__bridge_transfer id)p;
ARC 的代码相当于 MRC:
// MRC
id obj = (id)p;
[obj retain];
[(id)p release];
关于 OC 对象和 Core Foundation 对象
cf 对象用于 C语言写的 Core Foundation 框架中,使用引用计数管理,CFRetain 和 CFRelease 可以持有、释放对象。
OC 对象和 CF 对象区别很小,不同之处在于是由哪一种框架生成的。因此转换不需要使用额外的 CPU 资源,被称为免费桥(toll-free bridge)。
以下函数用于 OC 对象和 CF 对象转换:
// 调用 CFBridgingRetain 后需用调用 CFRelease 释放对象。
// After using a CFBridgingRetain on an NSObject,
// the caller must take responsibility for calling CFRelease at an appropriate time.
CFTypeRef _Nullable CFBridgingRetain(id _Nullable X) {
return (__bridge_retained CFTypeRef)X;
}
// 调用 CFBridgingRelease 后,就不要再调用 CFRelease 了。
id _Nullable CFBridgingRelease(CFTypeRef CF_CONSUMED _Nullable X) {
return (__bridge_transfer id)X;
}
CFBridgingRetain 把 Objective-C pointer 转换为 Core Foundation pointer 并转移内存管理职责,之后要调用 CFRelease 释放对象:
NSString *string = @"Get a string";
CFStringRef cfString = (CFStringRef)CFBridgingRetain(string);
// Use the CF string.
CFRelease(cfString);
CFBridgingRelease 把 Core Foundation-style object 转换为 Objective-C object,并转移内存管理职责给 ARC,之后不用再调用 CFRelease(Moves a non-Objective-C pointer to Objective-C and also transfers ownership to ARC):
CFStringRef cfName = ABRecordCopyValue(person, kABPersonFirstNameProperty);
NSString *name = (NSString *)CFBridgingRelease(cfName);
1.3.5 属性
ARC 有效时:
属性 | 所有权修饰符 |
---|---|
assign | __unsafe_unretained 修饰符 |
copy | __strong 修饰符 |
retain | __strong 修饰符 |
strong | __strong 修饰符 |
unsafe_unretained | __unsafe_unretained 修饰符 |
weak | __weak 修饰符 |
weak、strong、retain 只能修饰对象。assign 也可以修饰对象,和 weak 的区别是不会置 nil。
各个修饰符会在 1.4 节讲解。
1.3.6 数组
这里讲的是 C语言的动态数组:
- (void)testCArray {
// 声明动态数组指针
id __strong *array = nil; // 默认是 __autoreleasing
// NSObject * __strong *array = nil;
// 分配内存
size_t count = 5;
array = (id __strong *)calloc(count, sizeof(id));
// 使用数组
array[0] = [[NSArray alloc] init];
// 释放数组
for (int i = 0; i < count; i++) {
array[i] = nil; // 因为编译器不能确定生命周期
}
free(array); // 注意,free 前要设置为 nil。
// 注意,下面的代码是危险的
// malloc、memcpy 都是危险的,不要使用
// malloc 分配的内存没有初始化为 0
array = (id __strong *)malloc(count * sizeof(id));
for (int i = 0; i < count; i++) {
array[i] = nil; // 可能会释放一个不存在的对象
}
free(array);
}
1.4 ARC 的实现
ARC 是由编译器进行内存管理的。实际上,只有编译器是无法完全胜任的,还需要 OC 的运行时库的协助。
1.4.1 __strong 修饰符
先看 alloc/new/copy/mutableCopy 的方法:
{
id __strong obj = [[NSObject alloc] init];
}
// 编译器的模拟代码
id obj = objc_msgSend(NSObject, @selector(alloc));
objc_msgSend(obj, @selector(init));
obcj_release(obj);
编译器自动插入了 release。
再看不是 alloc/new/copy/mutableCopy 开头的方法:
{
id __strong obj = [NSMutableArray array];
}
// 编译器的模拟代码
id obj = objc_msgSend(NSMutableArray, @selector(array));
objc_retainAutoreleasedReturnValue(obj);
obcj_release(obj);
编译器插入了 objc_retainAutoreleasedReturnValue 函数,用来持有(retain)对象 obj,对象 obj 是一个返回值并且被注册到释放池。
objc_retainAutoreleasedReturnValue 和 objc_autoreleaseReturnValue 是成对出现的。前者是持有对象,后者可能会把对象注册到自动释放池。
这对函数优化的地方在于,如果调用 objc_autoreleaseReturnValue 后,紧接着又调用了 objc_retainAutoreleasedReturnValue,那么 objc_autoreleaseReturnValue 不会把对象注册到自动释放池,objc_retainAutoreleasedReturnValue 也能正确的获取到对象。如图 1-22 所示。
图 1-221.4.2 __weak 修饰符
__weak 修饰的变量,指向的对象废弃后,会被置 nil。
使用 __weak 修饰的变量,即是使用注册到自动释放池的对象。
下面看看它是如何实现的。
- (void)testWeak {
id __strong obj = [[NSObject alloc] init];
{
// 假设 obj 被 __stong 修饰,指向一个对象
id __weak objWeak = obj;
}
// 编译器的模拟代码
id objWeak;
objc_initWeak(&objWeak, obj);
objc_destroyWeak(&objWeak);
}
通过 objc_initWeak 初始化变量,超出范围时通过 objc_destroyWeak 释放。
objc_initWeak 先把变量置 0,然后调用 objc_storeWeak 函数:
objWeak = 0;
objc_storeWeak(&objWeak, obj);
objc_destroyWeak 将 0 作为参数调用 objc_storeWeak 函数:
objc_storeWeak(&objWeak, 0);
也就是 testWeak 函数相当于:
// 编译器的模拟代码
id objWeak;
objWeak = 0;
objc_storeWeak(&objWeak, obj);
objc_storeWeak(&objWeak, 0);
散列表也叫哈希表,通过散列函数,把 key 映射为一个位置来访问记录,存放记录的数组叫做散列表。
weak 表是个散列表,应该是以对象的地址作为 key,根据散列函数得到的位置,保存所有指向该对象的 __weak 变量的地址。
比如 objc_storeWeak 函数把 obj 的地址作为 key,映射得到位置后,把变量 objWeak、objWeak2、objWeak3 的地址都保存到这个位置。
如果 objc_storeWeak 的第二个参数为 0,则把 objWeak 的地址从 weak 表中删除 (传 0 是怎么找到变量地址的???)。
废弃对象的步骤:
- objc_release
- 因为引用计数为 0 所以执行 dealloc
- _objc_rootDealloc
- object_dispose
- objc_destructInstance
- objc_clear_deallocating
对象被废弃时,调用的 objc_clear_deallocating 的动作如下:
- 以废弃对象的地址为 key,从 weak 表获取记录。
- 将记录中所有 __weak 变量赋值为 nil。
- 从 weak 表中删除该记录。
- 从引用计数表中,删除以废除对象地址为 key 的记录。
以上步骤实现了对象废弃时,__weak 变量赋值为 nil 的功能。
下面讲解 __weak 的另一功能:使用 __weak 修饰的变量,即是使用注册到自动释放池的对象。
{
id __weak objWeak = obj;
NSLog(@"%@", objWeak);
}
// 编译器的模拟代码
id objWeak;
objc_initWeak(&objWeak, obj);
id tmp = objc_loadWeakRetained(&objWeak);
objc_autorelease(tmp);
NSLog(@"%@", tmp);
objc_destroyWeak(&objWeak);
上面的代码增加了 objc_loadWeakRetained 和 objc_autorelease 的调用,
objc_loadWeakRetained 取出 weak 对象并 retain,
objc_autorelease 将对象注册到自动释放池中。
由此可知,在 @autoreleasepool 块结束前,__weak 修饰的变量指向的对象都可以放心使用。但是,每次使用 weak 变量,都会把它注册到释放池,比如 NSLog 5 次,就会注册 5 次,所以最好先暂时赋值给 __strong 修饰的变量后,再使用它:
id __weak o = obj;
id tmp = o; // 只有这句会把对象 o 注册到自动释放池
NSLog(@"1 %@", tmp);
NSLog(@"2 %@", tmp);
下面讲解对象的立即释放:
{
id __weak obj = [[NSObject alloc] init];
// NSLog(@"obj = %@", obj); 这里会输出 obj = (null)
}
以上代码,编译器会警告:Assigning retained object to weak variable; object will be released after assignment。
对象赋值给 __weak 变量后,编译器判断它没有持有者,会立即释放和废弃它,然后变量就会被赋值 nil:
// 编译器的模拟代码
id obj;
id tmp = objc_msgSend(NSObject, @selector(alloc));
objc_msgSend(tmp, @selector(init));
objc_initWeak(&obj, tmp); // 赋值给 weak 变量
obcj_release(tmp); // 判断没有持有者,释放它
objc_destroyWeak(&obj); // 超出作用域
如果不赋值给变量呢,能调用被立即释放的对象的实力方法吗:
// 加 void 是为了避免编译器警告
(void)[[[NSObject alloc] init] hash];
// 编译器的模拟代码
id tmp = objc_msgSend(NSObject, @selector(alloc));
objc_msgSend(tmp, @selector(init));
objc_msgSend(tmp, @selector(hash));
obcj_release(tmp);
可见在调用了实例方法后,对象才被释放。看来“由编译器进行内存管理”这句话是正确的。
1.4.3 __autoreleasing 修饰符
__autoreleasing 修饰等同于 ARC 无效时调用对象的 autorelease 方法。
alloc/new/copy/mutableCopy 方法群创建的对象:
@autoreleasepool {
id __autoreleasing obj = [[NSObject alloc] init];
}
// 编译器的模拟代码
id pool = objc_autoreleasePoolPush();
id obj = objc_msgSend(NSObject, @selector(alloc));
objc_msgSend(obj, @selector(init));
objc_autorelease(obj);
objc_autoreleasePoolPop(pool);
非 alloc/new/copy/mutableCopy 方法群创建的对象:
@autoreleasepool {
id __autoreleasing obj = [NSMutableArray array];
}
// 编译器的模拟代码
id pool = objc_autoreleasePoolPush();
id obj = objc_msgSend(NSMutableArray, @selector(array));
objc_retainAutoreleasedReturnValue(obj);
objc_autorelease(obj);
objc_autoreleasePoolPop(pool);
可见注册到自动释放池的方法都是 objc_autorelease。
1.4.4 引用计数
书上说,_objc_rootRetainCount 可以获取对象的引用计数。但我试了一下,不知道导入哪个头文件才不会报错。可以用另外的方法获取:
id __strong obj = [[NSObject alloc] init];
NSUInteger count = _objc_rootRetainCount(obj);
count = CFGetRetainCount((__bridge CFTypeRef)obj); // CFGetRetainCount
count = [[obj valueForKey:@"retainCount"] intValue]; // KVC
二、 Blocks
block 是带有自动变量(局部变量)的匿名函数。
2.2 block 模式
2.2.1 block 语法
block 型变量可以作为 自动变量、静态变量、全局变量、静态全局变量、函数参数。
- (void)test1 {
// 声明
int (^blk) (int);
// 创建
blk = ^ int (int count) {
return count +1;
};
// 没有返回类型或形参,可以省略
void (^block)(void); // 后面的 void 不能少哦
block = ^ {
NSLog(@"block 2");
};
// 作为参数
[self fun:blk];
// 作为返回值
blk = [self fun2];
}
// 函数参数。名字放在外面。
- (void)fun:(int (^)(int))blk {
blk(3);
}
// 函数返回值。不能有名字。
- (int (^)(int))fun2 {
return ^ int (int count) {
return count +1;
};
}
可以使用 typedef 定义 block:
typedef int (^blc_t)(int);
- (blc_t)fun3 {
// 创建 block
blc_t block = ^int (int count) {
return count + 1;
};
// 也可以使用指针.
// 不加 const 会报错:Pointer to non-const type 'blc_t' (aka 'int (^)(int)') with no explicit ownership
const blc_t *blockPointer = █
return block;
}
2.2.3 截获自动变量值
block 是带有自动变量的匿名函数。带有自动变量值在 block 中表现为截获自动变量值。
- (void)test1 {
int count = 1;
void (^blk)(void) = ^ {
NSLog(@"count = %d", count);
};
count = 2;
blk(); // 输出 count = 1
}
block 捕获了自动变量的值,保存的瞬间值。即使修改了变量的值再执行 block,也没有影响。
2.2.4 __block 说明符
block 不能直接修改自动变量的值,否则会报错:Variable is not assignable (missing __block type specifier)。
用 __block 修饰的变量,block 才可以修改它的值,并且在执行 block 时,拿到的变量的值是最新修改的。
- (void)test__block {
__block int count = 1;
NSMutableArray *array = [NSMutableArray array];
void (^blk)(void) = ^ {
NSLog(@"count = %d", count);
count = 3;
[array addObject:[NSObject new]]; // 不会报错
array = [NSMutableArray array]; // 会报错
};
count = 2;
blk(); // 输出 count = 2
}
2.3 Blocks 的实现
2.3.1 block 的实质
在终端 cd 到文件目录,输入 "clang -rewrite-objc 源代码文件名",可以转换成 cpp 文件。
定义一个继承自 NSObject 的 Test 类,有个 test 方法:
@implementation Test
- (void)test {
void (^blc)(void) = ^ {
printf("哈哈哈");
};
blc();
}
@end
代码转换后,先看 block 语法 ^ { printf("哈哈哈"); }
转换的代码:
// block 的函数,参数是一个 block 指针
static void __Test__test_block_func_0(struct __Test__test_block_impl_0 *__cself) {
printf("哈哈哈");
}
如代码所示,block 匿名函数转换成一个 C语言函数处理。函数名 __Test__test_block_func_0 由类名、所在函数名、在函数出现的顺序和 block_func 拼接成。
函数的参数 __cself 是一个指针,相当于 c++ 的变量 this,或 OC 的变量 self,指向一个 block 的结构体。
函数参数 __cself 的声明:
struct __Test__test_block_impl_0 *__cself
block 转换成结构体 __Test__test_block_impl_0,声明如下:
// 自定义 block 的结构体
struct __Test__test_block_impl_0 {
struct __block_impl impl; // block 的基本定义
struct __Test__test_block_desc_0* Desc; // block 的数据
// 构造函数。
// fp 是 block 的函数的指针,desc 是 block 的数据。
__Test__test_block_impl_0(void *fp, struct __Test__test_block_desc_0 *desc, int flags=0) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
结构体 _block_impl_0 里面有个构造函数,还有两个结构体变量:
block 的基本定义 __block_impl , block 的数据 _block_desc_0。
先看 __block_impl 的定义:
// block 的基本定义
struct __block_impl {
void *isa; // block 的类
int Flags;
int Reserved;
void *FuncPtr; // 指向 block 的函数
};
__block_impl 和 __Test__test_block_impl_0 有点类似父类和子类,后者会在前者的基础上增加自己的东西。所有自定义的 block 里面都有一个 __block_impl 指针,比如 __Test__test_block_impl_1、__Test__test_block_impl_2。
再看 __Test__test_block_desc_0 的定义:
// block 的数据
static struct __Test__test_block_desc_0 {
size_t reserved;
size_t Block_size;
} __Test__test_block_desc_0_DATA = { 0, sizeof(struct __Test__test_block_impl_0)};
// 上面创建的结构体实例 __Test__test_block_desc_0_DATA 会在调用构造函数的时候用到。
其结构为今后版本升级所需的区域和 block 的大小。
总结,自定义一个 block,会生成
一个 block 结构体 _block_impl_0、
一个 block 数据结构体 _block_desc_0、
一个 block 函数 _block_func_0、
所有 block 共用的结构体 __block_impl,
而 _block_impl_0 里面有一个 __block_impl 结构体指针、一个 _block_desc_0 指针、一个构造函数,里面可能还定义有截获的变量。
_block_impl_0 构造函数的实现:
// 构造函数
__Test__test_block_impl_0(void *fp, struct __Test__test_block_desc_0 *desc, int flags=0) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
fp 指向 block 要执行的代码所转换的函数 __Test__test_block_func_0,_NSConcreteStackBlock 用于初始化 isa 变量,具体后文会讲解。
Test 类的 test 函数转换后的代码:
static void _I_Test_test(Test * self, SEL _cmd) {
// 创建 block
void (*blc)(void) = ((void (*)())&__Test__test_block_impl_0((void *)__Test__test_block_func_0, &__Test__test_block_desc_0_DATA));
// 调用 block
( (void (*)(__block_impl *)) ((__block_impl *)blc) ->FuncPtr) ((__block_impl *)blc);
// 上面的代码去掉类型转换,可以看做下面的代码
{
// 创建 block
struct __Test__test_block_impl_0 tmp = __Test__test_block_impl_0(__Test__test_block_func_0, &__Test__test_block_desc_0_DATA));
struct __Test__test_block_impl_0 *blc = &tmp;
// 调用 block
(*blc->impl.FuncPtr)(*blc);
}
}
先创建一个 __Test__test_block_impl_0 结构体实例 tmp,然后把 tmp 的地址赋给指针 blc。结构体实例 tmp 保存在栈上。
构造函数有两个参数,第一个是 C语言函数指针,是 block 要执行的代码。
第二个是作为静态全局变量初始化的 __Test__test_block_desc_0 结构体实例指针 & __Test__test_block_desc_0_DATA,以下是它的初始化代码:
struct __Test__test_block_desc_0 __Test__test_block_desc_0_DATA = {
0,
sizeof(struct __Test__test_block_impl_0)
};
__Test__test_block_desc_0_DATA 使用 __Test__test_block_impl_0 的大小进行初始化。
构造函数的参数讲完了,看看 block 的初始化过程。假设把 __Test__test_block_impl_0 的 _block_impl 展开:
// 展开 __block_impl
struct __Test__test_block_impl_0 {
void *isa; // block 的类
int Flags;
int Reserved;
void *FuncPtr; // 指向 block 的函数
struct __Test__test_block_desc_0* Desc;
// 构造函数
__Test__test_block_impl_0(void *fp, struct __Test__test_block_desc_0 *desc, int flags=0) {
// ......
}
};
然后初始化会像下面这样:
isa = &_NSConcreteStackBlock;
Flags = 0;
Reserved = 0;
FuncPtr = __Test__test_block_func_0;
Desc = &__Test__test_block_desc_0_DATA;
接下来看 block 执行部分:
// 原代码
blc();
// 转换后
( (void (*)(__block_impl *)) ((__block_impl *)blc) ->FuncPtr) ((__block_impl *)blc);
// 简化后
(*blc->impl.FuncPtr)(*blc);
blc 其实是个指针,指向 __Test__test_block_impl_0,impl 指向 _block_impl,FuncPtr 指向 __Test__test_block_func_0。
到此已经摸清了 block 的实质,下面解释 block 的 isa 指针。
block 其实是 OC 对象。
打开 objc.h 文件,或者 cmd + shift + o,输入 objc_object 可以找到相关定义。下面的定义都是 OC 1.0 的,2.0 的在这里:https://opensource.apple.com/source/objc4/objc4-750.1/runtime/objc-runtime-new.h.auto.html。
先看对象指针 id 的定义:
/// A pointer to an instance of a class.
typedef struct objc_object *id;
对象结构体 objc_object 的定义:
/// Represents an instance of a class.
struct objc_object {
Class isa;
};
类指针 Class 的定义:
/// An opaque type that represents an Objective-C class.
typedef struct objc_class *Class;
类结构体 objc_class 的定义:
struct objc_class {
Class isa;
// Objective-C 2.0 已经改了
#if !__OBJC2__
Class super_class OBJC2_UNAVAILABLE;
const char * name OBJC2_UNAVAILABLE;
long version OBJC2_UNAVAILABLE;
long info OBJC2_UNAVAILABLE;
long instance_size OBJC2_UNAVAILABLE;
struct objc_ivar_list * ivars OBJC2_UNAVAILABLE;
struct objc_method_list * * methodLists OBJC2_UNAVAILABLE;
struct objc_cache * cache OBJC2_UNAVAILABLE;
struct objc_protocol_list * protocols OBJC2_UNAVAILABLE;
#endif
} OBJC2_UNAVAILABLE;
/* Use `Class` instead of `struct objc_class *` */
可见在 OC 1.0 中,结构体 objc_object 和 objc_class 是相同的:
指针 | 结构体 | 属性 |
---|---|---|
id | objc_object | Class isa |
Class | objc_class | Class isa |
OC 的对象由类生成,意味着对象结构体实例的 isa 指针指向生成它的类的结构体实例。如下图所示:
OC 类与对象的实质各类的结构体就是基于 objc_class 结构体的 class_t 结构体(这是书上原话)。书上说在 objc-runtime-new.h 可以找到 class_t 的定义,但是我没找到。我在转换后的 cpp 文件里面找到 _class_t 的定义。
_class_t 的定义:
struct _class_t {
struct _class_t *isa;
struct _class_t *superclass;
void *cache;
void *vtable;
struct _class_ro_t *ro;
};
看到这里分不清 objc_object、objc_class、_class_t 的关系,这里只需要知道,block 结构体也有个 isa 指针,block 本质是个 OC 对象。比如 __Test__test_block_impl_0 的 isa = &_NSConcreteStackBlock,_NSConcreteStackBlock 相当于 _class_t 结构体。
举个例子:
@implementation Test
+ (void)load {
[[Test new] test];
}
- (void)test {
// 运行时断点显示为 __NSGlobalBlock__
// 编译的 cpp 文件显示 isa = &_NSConcreteStackBlock
// 原因后文会解释
void (^blc)(void) = ^ {
printf("哈哈哈");
};
blc();
}
@end
控制台断点输出:
(lldb) po [blc class]
__NSGlobalBlock__
(lldb) po [blc superclass]
__NSGlobalBlock
(lldb) po [[blc superclass] superclass]
NSBlock
(lldb) po [[[blc superclass] superclass] superclass]
NSObject
(lldb) po [[[[blc superclass] superclass] superclass] superclass]
nil
可见 block 确实是对象,继承链为 NSGlobalBlock、NSBlock、NSObject。
2.3.2 截获自动变量值
block 通过定义一个相同的变量,来截获自动变量值。
- (void)test {
int count = 2;
void (^blc)(void) = ^ {
printf("哈哈哈 count = %d", count);
};
blc();
}
转换后的代码:
struct __Test__test_block_impl_0 {
struct __block_impl impl;
struct __Test__test_block_desc_0* Desc;
int count;
__Test__test_block_impl_0(void *fp, struct __Test__test_block_desc_0 *desc, int _count, int flags=0) : count(_count) {
impl.isa = &_NSConcreteStackBlock;
// 。。。
}
};
与之前的代码相比,多了个成员变量 count,而且声明和自动变量是一样的。构造函数也多了个 count 参数。
block 函数:
static void __Test__test_block_func_0(struct __Test__test_block_impl_0 *__cself) {
int count = __cself->count; // bound by copy
printf("哈哈哈 count = %d", count);
}
通过指向 block 的指针 __cself 来访问成员变量 count。
2.3.3 __block 说明符
block 通过定义一个相同的变量来截获自动变量值,因此无法在 block 中修改变量的值。
block 通过定义一个指针来截获静态变量的地址,可以访问和修改静态变量的值。
对于全局静态变量和全局变量,不需要指针就能访问和修改它的值,因此 block 不需要额外定义成员变量来截获。
int global_var = 1; // 全局变量
static int static_global_var = 2; // 全局静态变量
- (void)test {
static int static_var = 3; // 局部静态变量
int count = 2;
void (^blc)(void) = ^ {
global_var *= 1;
static_global_var *= 2;
static_var *= 3;
printf("哈哈哈 count = %d", count);
};
blc();
}
转换后的代码:
struct __Test__test_block_impl_0 {
struct __block_impl impl;
struct __Test__test_block_desc_0* Desc;
int *static_var; // 新增局部静态变量的指针
int count;
};
block 函数:
static void __Test__test_block_func_0(struct __Test__test_block_impl_0 *__cself) {
// 通过指针访问局部静态变量
int *static_var = __cself->static_var;
int count = __cself->count; // bound by copy
global_var *= 1; // 全局变量直接访问
static_global_var *= 2; // 静态全局变量直接访问
(*static_var) *= 3; // 局部静态变量通过指针访问
printf("哈哈哈 count = %d", count);
}
对于自动变量,block 不截获它的指针,因为 block 无法控制自动变量的生命周期,通过指针访问有可能是野指针。
__block
__block 是存储域类说明符,类似于 static、auto 和 register 说明符,用于指定讲变量值设置到哪个存储域中。例如 auto 表示作为自动变量存储在栈中,static 表示作为静态变量存储在数据区中。
用 __block 修饰的自动变量,可以在 block 中修改,是因为自动变量被封装进一个结构体,block 截获了结构体实例指针。
- (void)test {
__block int var = 10;
void (^blc)(void) = ^ {
var *= 10;
};
blc();
}
转换的 block 结构体如下:
struct __Test__test_block_impl_0 {
struct __block_impl impl;
struct __Test__test_block_desc_0* Desc;
// 新增封装自动变量的结构体的指针
__Block_byref_var_0 *var; // by ref
};
block 新增一个指针,指向封装自动变量的结构体 __Block_byref_var_0。
__Block_byref_var_0 的定义:
struct __Block_byref_var_0 {
void *__isa;
// __forwarding 指向栈上的自己,或指向复制到堆的克隆结构体,后文会解释。
__Block_byref_var_0 *__forwarding;
int __flags;
int __size;
int var; // 这个是自动变量
};
在 test 方法中创建 __block 变量的代码:
// 原代码
__block int var = 10;
// 转换后
__Block_byref_var_0 var = {
0, // __isa
&var, // __forwarding
0, // __flags
sizeof(__Block_byref_var_0), // __size
10 // int var
};
原来创建一个自动变量的代码,变成了创建结构体实例。
block 函数:
static void __Test__test_block_func_0(struct __Test__test_block_impl_0 *__cself) {
__Block_byref_var_0 *var = __cself->var; // bound by ref
(var->__forwarding->var) *= 10;
}
block 函数通过 __cself 获取结构体实例的指针 var,然后通过 var 的 __forwarding 指针获取真正的结构体实例,然后再获取和结构体实例同名的成员变量 var。
__forwarding 指针如下图所示,后文会详细解释:
访问 __block 变量block 不截获自动变量的指针,是因为无法控制自动变量的生命周期。block 截获结构体实例的指针,为防止野指针,后面会解释 block 如何控制结构体实例的生命周期。(其实就是 block 被复制到堆时,结构体实例也会被复制到堆。)
2.3.4 Block 存储域
block 与 __block 变量的实质:
名称 | 实质 |
---|---|
block | 栈上 block 的结构体实例 |
__block 变量 | 栈上 __block 变量的结构体实例 |
block 有 3 种:
- _NSConcreteStackBlock
- _NSConcreteGlobalBlock
- _NSConcreteMallocBlock
_NSConcreteStackBlock 类的 block 设置在栈上,
_NSConcreteGlobalBlock 类的 block 设置在数据区域(.data 区),
_NSConcreteMallocBlock 类的 block 设置在由 malloc 分配的内存块(堆)。
全局 block:
void (^globalBlock)(void) = ^(){ printf("global block\n"); };
- (void)test {
globalBlock();
}
此 block 没有使用自动变量,因此不依赖于执行时的状态,所以整个程序中只需一个实例,和全局变量一样设置在数据区域就行。
栈 block:
- (void)test {
// 运行时是 _NSConcreteGlobalBlock
void (^stackBlock)(int) = ^(int count){ printf("stack block\n"); };
stackBlock(99);
}
此 block 不截获任何变量,不依赖于执行状态,只需要一个实例,所以设置在数据区域,也就是说,编译时是 _NSConcreteStackBlock,运行时会是 _NSConcreteGlobalBlock。
截获变量的栈 block:
- (void)test {
int var = 1;
// blc 编译是_NSConcreteStackBlock
// blc 运行时是 _NSConcreteMallocBlock,因为有强引用指向它
void (^blc)(int) = ^(int count) {
printf("var + count = %d", var + count);
};
blc(99);
// 编译是_NSConcreteStackBlock
// 输出 __NSStackBlock,因为没有强引用指向它
NSLog(@"%@", [(^(int count){ printf("var + count = %d", var + count); }) superclass]);
}
对于栈 block:
如果不依赖于执行状态,运行时会是 _NSConcreteGlobalBlock;
如果有强引用指向它,运行时会是 _NSConcreteMallocBlock。
栈上的 block 和 __block 变量,超出作用域就会被废弃。
将它们复制到堆上,超出作用域也可以继续存在。
ARC 有效时,编译器在大多数情形下会自动复制 block 到堆:
- block 作为函数的返回值;
- block 作为 Cocoa 框架带有 usingBlock 的函数的参数时;
- block 作为 GCD 的 API 的参数时;
- block 被强引用指向时;
block 作为函数参数传递时,除了 Cocoa 框架带有 usingBlock 的函数和 GCD 的 API,其他函数是不会被编译器 copy 到栈的,比如下面的情况:
- (NSArray *)getBlockArray {
int var = 10;
// 第一个是 __NSMallocBlock__,后面的是 __NSStackBlock__
NSArray *array = [NSArray arrayWithObjects:
^{NSLog(@"var = %d", var);},
^{NSLog(@"var = %d", var);},
^{NSLog(@"var = %d", var);},
nil];
return array;
}
- (void)test {
// 数组只有第一个没释放,后面的 block 都废弃了
NSArray *array = [self getBlockArray];
void (^blc)(void) = [array firstObject];
blc(); // 第一个可以正常运行,后面的会崩溃
blc = [array lastObject]; // 这里会崩溃,EXC_BAD_ACCESS
blc();
}
打断点可以看到,getBlockArray 函数的数组里 block 的情况。array 的第一个 block 按理应该是 栈 block,可能有强引用数组指针指向它,所以变成了 堆 block,然后后面的 block 都是 栈 block。
问题2341:数组不是会强引用它的元素吗,其他的 block 也应该是 堆 block 才对,求大神指点。
答:数组应该会 retain 它的元素,而 retain 方法对 栈 block 不起任何作用(要改用 copy,后文会解释 ),也就是不会拷贝到堆,所以超出作用域就会废弃。
运行到 test 函数,array 后面的 block 都废弃了,因为它们是 栈 block,已经超出了作用域。只有第一个 堆 block 没有废弃。
问题2342:数组会强引用它的元素,为什么还会被废弃呢?求大神指点。
答:数组会 retain 它的元素,而不是强引用它的元素,具体看问题2341。
对于编译器无法判断的情况,可以手动调用 copy 方法,比如上述代码可以增加调用 copy,array 里的 block 就都是堆 block:
- (NSArray *)getBlockArray {
int var = 10;
// 第一个是 __NSMallocBlock__,后面的是 __NSStackBlock__
NSArray *array = [NSArray arrayWithObjects:
[^{NSLog(@"var = %d", var);} copy],
[^{NSLog(@"var = %d", var);} copy],
[^{NSLog(@"var = %d", var);} copy],
nil];
return array;
}
不同类型的 block,调用 copy 的结果是不同的:
block 的类 | 原来的存储域 | 复制效果 |
---|---|---|
_NSConcreteStackBlock | 栈 | 从栈复制到堆 |
_NSConcreteGlobalBlock | 数据区域 | 什么也不做 |
_NSConcreteMallocBlock | 堆 | 引用计数增加 |
2.3.5 __block 变量存储域
上一节讲的是 block 存储域。block 复制到堆,__block 变量也会受影响:
__block 变量存储域 | 影响 |
---|---|
栈 | 从栈复制到堆,并被 block 持有 |
堆 | 被 block 持有 |
多个 block 使用同一个 __block 变量时,被复制到堆的 block 会持有变量,并增加变量的引用计数。如果堆上的 block 被废弃,那么它使用的变量也被释放,引用计数 -1。如果变量没有持有者,就会被废弃。
block 的废弃和 __block 变量的释放可见 __block 变量和 OC 对象的引用计数式内存管理完全相同。block 复制到堆会持有 __block 变量,如果 block 废弃就会释放 __block 变量。
__block 变量会被复制到堆,所以它的结构体有个 __forwarding 指针,使得不管 __block 变量配置在栈还是堆,都能正确访问该变量(这里可以理解成,访问的都是同一个变量)。
举个栗子:
- (void)test {
__block int var = 0;
int *p1 = &var; // 指向 var 的地址
// __weak 是避免强引用指向 block 导致复制到堆
__weak void (^blk0)(void) = ^{ ++var;};
blk0(); // 没有释放,正常运行
int *p2 = &var; // p2 和 p1 的值是一样的
// block 和 var 复制到堆
void (^blk3)(void) = [^{ ++var;} copy];
int *p3 = &var; // p3 的值和 p1 的不同了
var++;
blk0();
NSLog(@"var = %d", var);
}
++var 用的是堆上的,var-- 用的是栈上的,都可以通过 var.__forwarding->var 来正确访问。复制到堆时,会把堆的地址赋值给栈的 var 的 __forwarding 指针。如图:
__block 变量的 __forwarding 指针2.3.6 截获对象
之前讲过 block 截获自动变量、静态变量、全局变量、__block 变量,下面讲解截获对象。
被 __strong 修饰的变量指向的对象,会被堆 block 持有。
举个栗子:
- (void)test {
__strong void (^blk)(id); // 堆 block,会持有 array,最后输出 count = 3
// __weak void (^blk)(id); // 栈 block, 不持有 array,全部输出 count = 0
{
NSMutableArray *array = [NSMutableArray array];
blk = ^(id obj) {
[array addObject:obj];
NSLog(@"array count = %li", array.count);
};
}
blk([[NSObject alloc] init]);
blk([[NSObject alloc] init]);
blk([[NSObject alloc] init]);
}
array 超出作用域就应该被废弃了,可是控制台最后输出 count = 3,说明堆 block 会持有强引用指向的对象。(这个 block 被强引用持有,所以是个 堆 block。)
block 转换的代码如下:
struct __Test__test_block_impl_0 {
struct __block_impl impl;
struct __Test__test_block_desc_0* Desc;
NSMutableArray *__strong array;
};
block 结构体多了一个 __strong 修饰的成员变量 array。编译器不知道何时废弃 C语言结构体的 strong 变量,但 OC 运行时可以。
为了管理截获的 __strong 修饰的对象,生成了 _block_copy_0 和 _block_dispose_0 函数,结构体 _block_desc_0 也多了两个函数指针成员变量:
// 复制 block 时调用,用于赋值、持有
static void __Test__test_block_copy_0(struct __Test__test_block_impl_0*dst, struct __Test__test_block_impl_0*src) {
_Block_object_assign((void*)&dst->array, (void*)src->array, 3/*BLOCK_FIELD_IS_OBJECT*/);
}
// 废弃 block 时调用,用于释放
static void __Test__test_block_dispose_0(struct __Test__test_block_impl_0*src) {
_Block_object_dispose((void*)src->array, 3/*BLOCK_FIELD_IS_OBJECT*/);
}
static struct __Test__test_block_desc_0 {
size_t reserved;
size_t Block_size;
// 多了两个函数指针,指向上面的两个函数
void (*copy)(struct __Test__test_block_impl_0*, struct __Test__test_block_impl_0*);
void (*dispose)(struct __Test__test_block_impl_0*);
} __Test__test_block_desc_0_DATA = { 0, sizeof(struct __Test__test_block_impl_0), __Test__test_block_copy_0, __Test__test_block_dispose_0};
__Test__test_block_copy_0 函数在复制 block 到堆时会被调用,
__Test__test_block_dispose_0 函数在堆 block 废弃时被调用。
_Block_object_assign 函数相当于 retain 函数,将栈 block 的变量赋值给堆 block,并让堆 block 持有该变量指向的对象。参数 3 BLOCK_FIELD_IS_OBJECT 是指该变量是个对象。
_Block_object_dispose 函数相当于 release 函数,会释放堆 block 持有的对象。
block 复制到堆的时机:
- 调用 block 的 copy 方法时;
- block 作为函数的返回值时;
- block 赋值给 __strong 修饰的变量时;
- block 作为 Cocoa 框架带有 usingBlock 的函数
或 GCD API 的参数传递时,函数内部会自动复制。
上面的情况都可以归结为:调用 _Block_copy 函数将 block 从栈复制到堆。
在使用 __block 变量时,也会生成类似 __Test__test_block_copy_0 函数和 __Test__test_block_dispose_0 函数:
static void __Test__test_block_copy_0(struct __Test__test_block_impl_0*dst, struct __Test__test_block_impl_0*src) {
_Block_object_assign((void*)&dst->var, (void*)src->var, 8/*BLOCK_FIELD_IS_BYREF*/);
}
static void __Test__test_block_dispose_0(struct __Test__test_block_impl_0*src) {
_Block_object_dispose((void*)src->var, 8/*BLOCK_FIELD_IS_BYREF*/);
}
__block 变量和对象的区别是参数类型:
__block 变量 | BLOCK_FIELD_IS_BYREF |
---|---|
对象 | BLOCK_FIELD_IS_OBJECT |
2.3.7 __block 变量和对象
__block 说明符可以修饰任何类型的自动变量,包括对象类型。
- (void)test {
__block id __strong obj = [NSObject new];
void (^blk)(void) = ^ {
NSLog(@"%@", obj);
};
blk();
}
转换的代码:
// __block 变量结构体
struct __Block_byref_obj_0 {
void *__isa;
__Block_byref_obj_0 *__forwarding;
int __flags;
int __size;
void (*__Block_byref_id_object_copy)(void*, void*);
void (*__Block_byref_id_object_dispose)(void*);
// 自动变量 obj
__strong id obj;
};
// block 结构体
struct __Test__test_block_impl_0 {
struct __block_impl impl;
struct __Test__test_block_desc_0* Desc;
// __block 变量结构体指针
__Block_byref_obj_0 *obj; // by ref
};
// _block_copy_0
static void __Test__test_block_copy_0(struct __Test__test_block_impl_0*dst, struct __Test__test_block_impl_0*src) {
_Block_object_assign((void*)&dst->obj, (void*)src->obj, 8/*BLOCK_FIELD_IS_BYREF*/);
}
// _block_dispose_0
static void __Test__test_block_dispose_0(struct __Test__test_block_impl_0*src) {
_Block_object_dispose((void*)src->obj, 8/*BLOCK_FIELD_IS_BYREF*/);
}
在 block 使用附有 __strong 修饰的对象类型的自动变量的情况下,当 block 从栈复制到堆时,使用 _Block_object_assign 函数持有 Block 截获的对象。当堆上的 Block 被废弃时,使用 _Block_object_dispose 函数释放 Block 截获的对象。
由此可知,只要堆 block 存在,那么变量和对象就会持续处于被持有的状态。
__block 修饰的对象类型的变量和 __strong 修饰的情况类似。
使用 __weak 修饰,或同时使用 __weak 和 __block 修饰,堆 block 不会持有对象。
总结:
堆 block 会持有 __block 和 __strong。
block 复制到堆的时机:
调用 block 的 copy 方法时;
block 作为函数的返回值时;
block 赋值给 __strong 修饰的变量时;
block 作为 Cocoa 框架带有 usingBlock 的函数
或 GCD API 的参数传递时,函数内部会自动复制。
2.3.8 Block 循环引用
block 使用对象或使用对象的属性,都可能持有对象。
@interface Test()
@property (nonatomic, copy) NSString *myName;
@property (nonatomic, copy) void(^blc)(void);
@end
@implementation Test
- (void)test {
Test __weak *weakObj;
{
Test *obj = [Test new];
weakObj = obj;
obj.myName = @"name";
obj.blc = ^{
// Block implicitly retains 'self'; explicitly mention 'self' to indicate this is intended behavior.
NSLog(@"%@", _myName); // 不会循环引用
// Capturing 'obj' strongly in this block is likely to lead to a retain cycle.
// NSLog(@"%@", obj.myName); // 会循环引用
// NSLog(@"%@", weakObj.myName); // 不会循环引用
};
}
NSLog(@"weakObj = %@", weakObj);
}
使用 obj.myName 会循环引用,编译器会警告 "lead to a retain cycle"。因为 obj 被 __strong 修饰,block 也被复制到堆,所以 block 会持有 obj,而 obj 也持有 block,造成循环引用。
使用 weakObj.myName 不会循环引用,没有警告。因为堆 block 不会持有 __weak 修饰的变量指向的对象。
使用 _myName 也不会循环引用,编译器只是警告 "implicitly retains self"。按照以前,使用 _myName 也会循环引用才对,书上也是这么说的。可能是 9012 年,苹果优化了吧,这里并不会产生循环引用。
看使用 _myName 的代码转换后,block 确实声明了一个 strong 变量:
struct __Test__test_block_impl_0 {
struct __block_impl impl;
struct __Test__test_block_desc_0* Desc;
Test *const __strong self;
};
求大神指点,使用 _myName 为什么不会循环引用。
为避免循环引用,可以使用 __weak 和 __block 修饰符。
使用 __block 避免循环引用:
- (void)test {
Test __weak *weakObj;
{
Test *obj = [Test new];
weakObj = obj;
__block Test *tmp = obj;
obj.myName = @"name";
obj.blc = ^{
NSLog(@"%@", tmp.myName);
tmp = nil; // 赋值为 nil 才能解决循环引用
};
obj.blc(); // 如果不执行,会导致循环引用
}
NSLog(@"weakObj = %@", weakObj);
}
self 持有 block,block 持有 tmp,tmp 持有 self,形成循环引用。
tmp = nil 后,就只剩 self 持有 block,block 持有 tmp,破坏循环引用。
使用 __block 修饰 tmp,就是为了可以在 block 中修改 tmp = nil。
缺点是,block 一定要执行,否则 tmp 始终持有 self,就会造成内存泄露。
以上说的是 ARC 有效的情况。
在 ARC 无效时,通过使用 __block 来避免循环引用。
在 ARC 无效时,block 从栈复制到堆,不会 retain 有 __block 修饰的对象类型的自动变量。没有 __block 修饰就会被 retain。
2.3.9 copy/release
ARC 无效时:
- block 通过 release 方法释放;
- 堆 block 可以通过 retain 方法持有;
- block 还可以通过 copy 方法持有;
- copy 可以拷贝 block 到堆,并且持有。
注意啦,retain 方法对 栈 block 不起任何作用。通过 retain 只能持有 堆 block。
所以 ARC 无效的情况下,对于 block,推荐使用 copy 持有,而不是 retain。
可以使用 Block_copy、Block_release 函数代替 copy、release 方法。
使用方法以及引用计数的思考方式和 OC 的对象相同。
void (^heapBlock) (void) = Block_copy(stackBlock);
Block_release(heapBlock);
Block_copy、Block_release 其实就是之前出现过的 _Block_copy、_Block_release 方法,即 OC 运行时为 C语言准备的方法。
第三章 Grand Central Dispatch
GCD 的内容不展开讲了,可以看我的另一篇文章:《GCD》。
里面讲了 GCD 的 API,有大量例子。
第三章只记录要点。
3.2 GCD的API
Dispatch Queue 按照追加的顺序(先进先出)执行处理。
种类 | 说明 |
---|---|
Serial dispatch queue | 等待现在执行中处理结束 |
Concurrent dispatch queue | 不等待现在执行中处理结束 |
串行队列要等当前任务完成,才会开始下一个。
并行队列只要开启了前面的任务,不需要等待完成,就可以开始下一个任务。
执行的任务数量和线程数量,由系统决定。并行队列会派发任务到多个线程执行。
通过 dispatch_queue_create 创建队列。
在 ARC 有效时,不需要手动管理内存。
在 MRC 通过 dispatch_retain 和 dispatch_release 管理内存,对 main dispatch queue 和 global dispatch queue 没有作用。
追加到队列的 block 会通过 dispatch_retain 函数持有队列,执行结束通过 dispatch_release 释放队列。
3.2.4 dispatch_set_target_queue
使用 dispatch_set_target_queue 可以设置自己创建的队列的优先级:
void dispatch_set_target_queue(dispatch_object_t object, dispatch_queue_t queue);
修改 object 的优先级与 queue 相同。queue 可以是 dispatch_get_global_queue 获取的全局队列。
假设有多个要串行执行的任务,派发到多个并行执行的串行队列执行,通过 dispatch_set_target_queue 把多个串行队列的目标队列,设置为同一个串行队列,就可以让这些任务串行执行。
如果只想获得某个优先级的队列,可以通过 dispatch_queue_attr_make_with_qos_class 创建队列属性,在创建队列时使用。
3.2.5 dispatch_after
dispatch_after 用于延迟派发 block,派发不等于执行。比如派发 block 到队列是 3 秒后,开始执行 block 的时间可能大于 3 秒。
参数 dispatch_time_t 通过 dispatch_time 函数或 dispatch_walltime 函数创建,前者是相对时间,后者是绝对时间。相对时间是指系统休眠时,计时会暂停,绝对时间就不会暂停,到点就触发。参数以纳秒为单位,比如 3 秒可以写为 3 * NSEC_PER_SEC。当前时间是 DISPATCH_TIME_NOW。
// 3 秒后
dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC));
3.2.6 Dispatch Group
Dispatch Group 可以在所有并行任务执行完后,追加执行一个任务,通过 dispatch_group_notify 追加。
另外,也可以不使用 dispatch_group_notify 追加,可以通过 dispatch_wait 来阻塞当前线程,可以设定超时的时间,不可以取消等待。所有任务完成或超时,dispatch_wait 函数就会返回。
dispatch_group_async 可以异步派发任务。
对于异步函数,可以在函数外部调用 dispatch_group_enter,在函数的回调里调用 dispatch_group_leave。比如网络库 af 的异步请求。
- (void)testDispatchGroup {
// group 会在所有任务完成后释放
dispatch_group_t group = dispatch_group_create();
// queue 会在所有 block 完成后释放
dispatch_queue_t queue = dispatch_get_global_queue(QOS_CLASS_DEFAULT, 0);
// 任务数是指 dispatch_group_t 内部的一个 count 属性。
// 任务数 +1
dispatch_group_async(group, queue, ^{
[NSThread sleepForTimeInterval:3];
NSLog(@"group async 完成");
// block 执行后,任务数 -1
});
dispatch_group_enter(group); // 任务数 +1
// 异步下载图片
[self downloadImageWithComplete:^(UIImage *image) {
NSLog(@"group downloadImage 完成");
dispatch_group_leave(group); // 任务数 -1
}];
// 所有任务完成,即任务数 = 0 时,会提交 block 到 queue。
dispatch_group_notify(group, queue, ^{
NSLog(@"group notify");
});
// 控制台输出
// 2019-06-13 21:06:58.911399+0800 group downloadImage 完成
// 2019-06-13 21:06:59.90973+0800 group async 完成
// 2019-06-13 21:06:59.910374+0800 group notify
}
- (void)downloadImageWithComplete:(void(^)(UIImage *image))block {
dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
dispatch_async(queue, ^{
[NSThread sleepForTimeInterval:2];
block(nil);
});
}
3.2.7 dispatch_barrier_async
dispatch_barrier_async 可以派发阻塞任务,当阻塞任务前面的任务都完成后,它才会执行,并且等它执行结束,它后面的任务才能开始执行。
注意 dispatch_barrier_async 只能用于自定义的全局队列,不要用于串行队列,或系统创建的全局队列、主队列,否则会当 dispatch_async 处理。(书上没写,源自 API 的注释。)
3.2.8 dispatch_sync
同步派发,会阻塞当前线程,直到派发任务完成。
下面的代码在主线程执行会死锁:
dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_sync(queue, ^{NSLog(@"Hello?");});
串行队列可能造成死锁,比如在一个任务 A 里面,给自己同步派发一个任务 B。因为是同步派发,所以会阻塞任务 A 的执行,等待任务 B 完成。但串行队列只能开始一个任务,所以任务 B 也在等待任务 A 的完成,于是造成了死锁。
3.2.9 dispatch_apply
同步并发迭代。阻塞当前线程,将 block 分配到多个线程,总共并发执行指定的次数。
并发执行 5 次:
dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
dispatch_apply([array count], queue, ^(size_t index) {
NSLog(@"%zu: %@, index, array[index]);
));
NSLog(@"done");
输出为:
4
1
0
2
3
done
3.2.10 dispatch_suspend/dispatch_resume
暂停执行:
dispatch_suspend(queue);
恢复执行:
dispatch_resume(queue);
3.2.11 Dispatch Semaphore
信号量可以控制线程的最大并发数,比如控制最大并发数为 1,就是串行了。
AFNetworking 的代码:
- (NSArray *)tasksForKeyPath:(NSString *)keyPath {
__block NSArray *tasks = nil;
dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
[self.session getTasksWithCompletionHandler:^(NSArray *dataTasks, NSArray *uploadTasks, NSArray *downloadTasks) {
if ([keyPath isEqualToString:NSStringFromSelector(@selector(dataTasks))]) {
tasks = dataTasks;
} else if ([keyPath isEqualToString:NSStringFromSelector(@selector(uploadTasks))]) {
tasks = uploadTasks;
} else if ([keyPath isEqualToString:NSStringFromSelector(@selector(downloadTasks))]) {
tasks = downloadTasks;
} else if ([keyPath isEqualToString:NSStringFromSelector(@selector(tasks))]) {
tasks = [@[dataTasks, uploadTasks, downloadTasks] valueForKeyPath:@"@unionOfArrays.self"];
}
dispatch_semaphore_signal(semaphore);
}];
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
return tasks;
}
终于写完了,欢迎指正错误。