iOS | 内存管理(MRC和ARC的区别以及实现)
自动引用计数(ARC)是指内存管理中对引用采取自动计数的技术。
使用ARC，就无需再次键入retain或者release代码，这降低了程序崩溃，内存泄漏等风险的同时，很大程度上减少了开发程序的工作量。ARC技术使得编译器清楚目标对象，并能立刻释放那些不再被使用的对象。如此一来，应用程序将具有可预测性，且能流畅运行，速度也将大幅提升。
MRC
人工引用计数（Manual Reference Counting）
内存管理的思考方式：
- 自己生成的对象，自己持有
- 非自己生成的对象，自己也能持有
- 不需要自己持有的对象时释放
- 无法释放非自己持有的对象
| 对象操作 | oc方法 |
|---|---|
| 生成并持有对象 | alloc/new/copy/mutableCopy 等方法 |
| 持有对象 | retain 方法 |
| 释放对象 | release 方法 |
| 废弃对象 | dealloc 方法 |
自己生成的对象，自己持有
- alloc
- new
- copy
- mutablecopy
id obj = [[NSObject alloc] init];
id obj = [NSObject new];
// 两者完全一致，生成并持有对象
// NSCopying和NSMutableCopying
非自己生成的对象，自己也能持有
id obj = [NSMutableArray array];
// 取得的对象存在，但自己不持有
[obj retain];
// 自己持有对象
不再需要自己持有的对象时释放
自己持有的对象，一旦不再需要，持有者有义务释放该对象。
id obj = [NSMutableArray array];
// 取得的对象存在，但自己不持有
[obj retain];
// 自己持有对象
[obj release];
// 释放对象
// 对象不可再被访问
array方法的实现
- (id) object
{
id obj = [[NSObject alloc] init];
// 自己持有对象
[obj autorelease];
// 释放后取得的对象存在，但自己不持有该对象
return obj;
}
release方法时调用后立即释放，而autorelease方法则是不立即释放而是注册到autoreleasepool中，在超出指定的生存范围时能够自动并正确释放(调用release)。
id obj1 = [obj0 object];
// 取得对象存在但不持有
[obj1 retain];
// 自己持有对象
无法释放非自己持有的对象
- 已经释放过的对象再一次释放。
id obj = [NSObject alloc] init];
[obj release];
[obj release];
- 自己还未持有的对象进行释放
id obj1 = [obj0 object];
[obj1 release];
alloc/retain/release/dealloc的实现
id obj = [NSObject alloc];
+(id)alloc
{
return [self allocWithZone: NSDefaultMallocZone()];
}
+(id)allocWithZone:(NSZone*)z
{
return NSAllocateObject(self, 0, z);
}
//
struct obj_layout
{
NSUInteger retained;
};
inline id NSAllocateObject (Class aClass, NSUInteger extraBytes, NSZone *zone)
{
int size = 计算容纳对象所需内存大小;
id new = NSZoneMalloc(zone, self);
memset(new, o, size);
new = (id)&((struct obj_layput *)new)[1];
}
NSDefaultMallocZone和NSZoneMalloc中包含的NSZone时防止内存碎片化而引入的结构，对内存分配的区域本身进行多重化管理，根据使用对象的目的，对象的大小分配内存，从而提高了内存管理的效率。
去掉NSZone后代码简化版
struct obj_layout
{
NSUInteger retained;
};
+(id) alloc
{
int size = sizeof(struct obj_layout) + 对象大小;
struct obj_layout *p = (struct obj_layout *)calloc(1, size);
return (id)(p+1);
}
方法中的retain整数用来保持引用计数并将其写入对象内存头部。
对象的引用计数通过retainCount来实现
id obj = [[NSObject alloc] init];
[obj retainCount];
- (NSUInteger)retainCount
{
return NSExtraRefCount(self) + 1;
}
inline NSUInteger NSExtraRefCount(id anObject)
{
return ((struct obj_layout *)anObject)[-1].retained;
}
通过retain方法可使retained变量加1，通过release方法可使retained变量减1
retain方法的实现：
-(id)retain
{
NSIncrementExtraRefCount(self);
return self;
}
inline void NSIncrementExtraRefCount(id anObject)
{
if (((struct obj_layout *) anObject)[-1].retained == UINT_MAX - 1)
[NSException raise: NSInternalInconsistencyException format: @"....."];
((struct obj_layout *) anObject)[-1].retained++;
}
release方法的实现
- (void)release
{
if (NSDecrementExtraRefCountWasZero(self))
[self dealloc];
}
BOOL NSDecrementExtraRefCountWasZero (id anObject)
{
if ((struct obj_layout *) anObject)[-1].retained == 0) {
return YES;
}
else
{
((struct obj_layout *)anObject)[-1].retained--;
return NO;
}
}
dealloc方法的实现
-(void)dealloc
{
NSDeallocateObject(self);
}
inline void NSDeallocateObject (id anObject)
{
struct obj_layout *o = &((struct obj_layout *) anObject)[-1];
free(o);
}
// 废弃alloc分配的内存块
实际上苹果是通过散列表的形式实现引用计数的，散列表的键值为内存块地址的散列值。
散列表存储信息为引用计数以及内存块地址。
autorelease
autorelease会类似c语言中的自动变量来对待对象实例，超出作用域时则将对象释放。
{
int a;
}
autorelease就是类似 { } 的作用，使用方法如下：
- 生成并持有NSAutoreleasePool对象
- 调用已分配对象的autorelease实例方法。
- 废弃NSAutoreleasePool对象。
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
id obj = [[NSObject alloc] init];
[obj autorelease];
[pool drain]; //等同于[obj release]
在Cocoa框架中，相当于程序主循环的NSRunLoop或者在其他程序可运行的地方，对NSAutoreleasePool 对象进行生成、持有和废弃处理。因此开发者不一定非得使用NSAutoreleasePool对象来进行开发工作。
但是在大量产生autorelease对象时，只有不废弃NSAutoreleasePool对象，那么生成的对象就不能被释放，因此可能出现内存不足的情况。例如：
for (int i = 0; i < 图像数; ++i)
{
/*
* 读入图像
* 大量产生autorelease对象
* 没有废弃NSAutoreleasePool 对象
* 导致最终内存不足
*/
[pool drain];
/*
* 通过drain方法autorelease对象被release
*/
}
Cocoa框架中也有很多类方法返回autorelease对象，比如NSMutableArray类的arrayWithCapacity类方法。
id array = [NSMutableArray arrayWithCapacity:1];
等同于
id array = [[[NSMutableArray alloc] initWithCapacity:1] autorelease];
autorelease的实现
[obj autorelease]
-(id)autorelease
{
[NSAutoreleasePool addObject:self];
}
+(void)addObject:(id)anObj
{
NSAutorelease *pool = 取得正在使用的NSAutorelease对象;
if (pool != nil)
{
[pool addObject:anObj];
}
else
{
NSLog(@"AutoreleasePool 对象非存在状态下调用");
}
}
如果嵌套生成或持有多个NSAutoreleasePool对象，则会使用最内侧的对象。
[pool drain]
- (void)drain
{
[self dealloc];
}
- (void) dealloc
{
[self emptyPool];
[array release];
}
- (void) emtpyPool
{
for (id obj in array)
{
[obj release];
}
}
ARC
与MRC的引用计数式内存管理在本质上没有太大变化，只是自动帮我们处理引用计数的部分。
通过__strong修饰符可以不必再次键入retain或者release，自动地实现了上述的四种内存管理思考方式。
但引用计数式内存管理会发生"循环引用"的问题。
{
id test0 = [[Test alloc] init]; /* 对象A */
/*
* test0 持有Test对象A的强引用
*/
id test1 = [[Test alloc] init]; /* 对象B */
/*
* test1 持有Test对象B的强引用
*/
[test0 setObject:test1];
/*
* 此时持有Test对象B的强引用变量为test1和对象A的obj_成员变量
*/
[test1 setObject:test0];
/*
* 此时持有Test对象A的强引用变量为test0和对象B的_obj变量
*/
}
/*
* 因为test0变量超出其作用域，强引用失效，所以自动释放对象A
*
* 因为test1变量超出其作用域，强引用失效，所以自动释放对象B
*
* 此时持有对象A的强引用变量为对象B的_obj，持有对象B的强引用变量为对象A的_obj
*
* 发生内存泄漏！(应当废弃的对象在超出其生命周期后依然存在)
*/
同时像下面的情况，虽然只有一个对象，但对象持有其自身时也会发生循环引用。
id test = [[Test alloc] init];
[test setObject:test];
使用弱引用__weak可以实现，弱引用不持有对象，只是持有该对象的强引用，如果该对象的所有强持有者都释放，则对象废弃，即使此时仍有弱持有者。
_unsafe_unretained 和weak的不同之处在于前者在赋值给带有strong修饰符的变量必须确保被赋值对象确实存在，不然其不会像weak一样被设置为nil而是造成悬浮指针。(存在是历史遗留问题，有了weak后基本不用它了)
strong修饰符类似于c++中的std::shared_ptr指针，而weak修饰符类似于c++中的std::weak_ptr，在c++中没有strong，weak强烈推荐使用这两个指针。
ARC，MRC区别
说了这么多总结一下ARC，MRC的区别吧。MRC类似于c++中的普通指针，程序猿要手动的进行生成持有释放废弃操作，但是可以将其注册到autoreleasepool中(类似c++的作用域)，在作用域消失时也就是autoreleasepool对象释放时会释放所有注册在它里面的对象。而ARC则是类似于c++的智能指针，不需要显示的对对象实例进行释放，出现了strong，weak等修饰符，采用自动引用计数的方法，使得当一个对象实例在强引用计数为0时，则废弃这个对象实例，释放其所占的内存块。
ARC的规则：
- 在ARC有效时编译代码一定要遵守以下规则，
- 不能使用NSAllocateObject/NSDeallocateObject
- 须遵守内存管理的命名规则
- init返回的必须是实例对象
- 不要显式地调用dealloc
- 使用@autorelease块代替NSAutoreleasePool
- 不能使用NSZone
- 对象型变量不能作为C语言结构体成员
- 显式转换id和void*
- 不能强制转换
- 如果只是想单纯地赋值可以通过__bridge转换，但可能造成悬空指针问题，不推荐。
ARC中的属性：
| 属性声明 | 所有权修饰符 |
|---|---|
| assign | _unsafe__unretained修饰符 |
| copy | __strong修饰符 |
| retain | __strong修饰符 |
| strong | __strong修饰符 |
| unsafe_unretained | _unsafe__unretained修饰符 |
| weak | __weak修饰符 |
-
**assign：**对应到__unsafe_unretained, 表明setter仅做赋值，不增加对象的引用计数，用于基本数据类型
-
__weak修饰符赋值后不会注册到autoreleasepool中，只会在使用时注册，而且每次使用都会注册一次，在autoreleasepool结束后会全部释放。
-
**copy：**对应到__strong，但是赋值操作比较特殊：赋值时进行copy而非retain操作，原来的值可变则深拷贝，不可变则浅拷贝。
ARC的实现
__strong
先看如下一段代码:
{
// ARC中默认会在对象前添加一个修饰符__strong
id obj = [[NSObject alloc] init];
//<==>等价于
id __strong obj = [[NSObject alloc] init];
}
根据runtime特性,它的实际调用如下:
{
// 消息转发
id obj = objc_msgSend(NSObject,@selector(alloc));
objc_msgSend(obj,@selector(init));
// 编译器在obj作用域结束时自动插入release
objc_release(obj);
}
当然这里是以alloc/new/copy/mutableCopy生成的对象,这种对象会被当前的变量所持有,引用计数会加1.那如果不是用被持有的方式生成对象呢?
看下面这段代码:
{
id obj = [NSMutableArray array];
}
这种方式生成的对象不会被obj持有,通常情况下会被注册到autoreleasepool中.但也有特殊情况,上面的代码可以转换成如下代码:
{
// 消息转发
id obj = objc_msgSend(NSMutableArray,@selector(array));
// 调用objc_retainAutoreleasedReturnValue函数
objc_retainAutoreleasedReturnValue(obj);
// 编译器在obj作用域结束时自动插入release
objc_release(obj);
}
这里介绍两个相关函数:
- objc_retainAutoreleasedReturnValue():这个函数的作用是返回注册在
autoreleasepool当中的对象. - objc_retainAutoreleaseReturnValue():这个函数一般是和
objc_retainAutoreleasedReturnValue()成对出现的.目的是注册对象到autoreleasepool中.但不仅限于此.
为何说不仅限于此呢?原因在于,objc_retainAutoreleaseReturnValue()函数在发现对象调用了方法或者函数之后又调用了objc_retainAutoreleasedReturnValue(),那么就不会再把返回的对象注册到autoreleasepool中了,而是直接把对象传递过去.
这样的好处显而易见:不用再去autoreleasepool中取出对象,传递出去,而是越过autoreleasepool直接传递,提升了性能.
__weak
weak修饰符想必大家都非常熟悉,它有一个众所周知的特性:用weak修饰的对象在销毁后会被自动置为nil.另外还补充一点:凡是用weak修饰过的对象,必定是注册到autoreleasepool中的对象.
看下面的代码:
{
// obj默认有__strong修饰
id obj = [[NSObject alloc] init];
id __weak obj1 = obj;
}
实际过程如下:
{
// 省略obj的实现
id obj1;
// 通过objc_initWeak初始化变量
objc_initWeak(&obj1,obj);
// 通过objc_destroyWeak释放变量
objc_destroyWeak(&obj1);
}
objc_initWeak()函数的作用是将obj1初始化为0,然后将obj作为参数传递到这个函数中objc_storeWeak(&obj1,obj)objc_destroyWeak()函数则将0作为参数来调用:objc_storeWeak(&obj1,0)objc_storeWeak()函数的作用是以第二个参数(obj || 0)作为key,第一个参数(&obj1)作为value,将第一个参数的地址注册到weak表中.当key为0,即从weak表中删除变量地址.
那么weak表中的对象是如何被释放的呢?
- 从weak表中获取废弃对象的键值记录.
- 将记录中所有包含__weak的变量地址,赋值为nil.
- 从weak表中删除该记录.
- 从引用计数表中删除对应的记录.
这就是__weak修饰的变量会在释放后自动置为nil的原因.同时,因为weak修饰之后涉及到注册到weak表等相关操作,如果大量使用weak可能会造成不必要的CPU资源浪费,所以书里指出尽量在循环引用中使用weak.
这里不得不提到另外一个和__weak相近的属性:__unsafe_unretained,它与weak的区别在于,释放对象后不会对其置为nil,在某些特定的场合下,需要延迟释放的时候,可以考虑用这个属性修饰.
好了,下一个问题,看如下代码:
{
id __weak obj1 = obj;
// 这里使用了obj1这个用weak修饰的变量
NSLog(@"%@",obj1);
}
在weak变量被使用的情况下,实际过程如下:
{
id obj1;
objc_initWeak(&obj1,obj);
id tmp = objc_loadWeakRetained(&obj1);
objc_autorelease(tmp);
NSLog(@"%@",tmp);
objc_destroyWeak(&obj1);
}
从这段实现代码中我们可以看出如下几点:
- 当我们使用weak修饰的对象时,实际过程中产生了一个
tmp对象,因为objc_loadWeakRetained()函数会从weak表中取出weak修饰的对象,所以tmp会对这个取出的对象进行一次强引用. - 因为上述原因,weak修饰的对象在当前变量作用域结束前都可以放心使用.
objc_autorelease()会将tmp对象也注册到autoreleasepool中.所以当大量使用weak对象的时候,注册到autoreleasepool的对象会大量增加.解决方案就是用一个__strong修饰的临时变量来使用.
{
id __weak obj1 = obj;
id tmp = obj1;
// 后面使用tmp即可
}
延伸一下:为什么有循环引用block内用weakObject的时候最好能在block内套一层strongObject?
- 在异步线程中weakObject可能会被销毁,所以需要套一层strong.
- 如果内部有耗时的循环语句,频繁使用weakObject也会增加内存损耗.
!!! 为什么访问weak修饰的对象就会访问注册到自动释放池的对象呢?
因为weak不会引起对象的引用计数器变化，因此，该对象在运行过程中很有可能会被释放。所以，需要将对象注册到自动释放池中并在autoreleasePool销毁时释放对象占用的内存。
__autoreleasing
它的主要作用就是将对象注册到autoreleasepool中.没啥好说的.
最后补充几种在ARC环境下获取引用计数的方法,但并不一定准确:ARC的一些引用计数优化,以及多线程的中的竞态条件问题,有兴趣的可以自己去了解一下.
(1) 使用_objc_rootRetainCount()私有函数
OBJC_EXTERN int _objc_rootRetainCount(id);
@interface ViewController ()
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
id obj = [[NSObject alloc] init];
NSLog(@"%d",_objc_rootRetainCount(obj));
}
@end
(2) 使用KVC
@interface ViewController ()
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
id obj = [[NSObject alloc] init];
NSLog(@"%d",[[obj valueForKey:@"retainCount"] integerValue]);
}
@end
(3) 使用CFGetRetainCount()
@interface ViewController ()
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
id obj = [[NSObject alloc] init];
NSLog(@"%d",CFGetRetainCount((__bridge CFTypeRef)(obj)));
}
@end