内存管理—MRC时代的手动内存管理
内存管理系列文章
内存管理—MRC时代的手动内存管理
内存管理—weak的实现原理
内存管理——autorelease原理分析
内存管理——定时器问题
iOS程序的内存布局
MRC时代的手动内存管理
iOS中是通过【引用计数】来管理OC对象的内存的。
- 一个新创建的OC对象引用计数默认是1，当引用计数减为0，OC对象就会销毁，其占用的内存空间会被系统释放。
- 调用
retain会让OC对象的引用计数+1，调用release会让OC对象的引用计数-1。
内存管理的原则
- 当调用
alloc、new、copy、mutableCopy方法返回了一个对象，再不需要这个对象时，要调用release或者autorelease来释放它。 - 想拥有某个对象，就让它的引用计数+1，不想再拥有某个对象，就让他的引用计数-1。
可以通过一下私有函数来查看自动释放池的情况
extern void _objc_autoreleasePoolPrint(void);
下面我们通过案例来分析一波
//********* main.m ************
#import 我们从在main.m里面通过alloc创建一个CLPerson实例，通过打印可以看到其引用计数为1，
2019-08-27 09:12:45.362995+0800 MRCManager[10928:615055] retainCount ----- 1
并且没有看到person调用dealloc方法，说明在main函数结束之后，person并没有被释放。那么我们在使用完person之后给加上一句release，如下
CLPerson *person = [[CLPerson alloc] init];
NSLog(@"retainCount ----- %zd",[person retainCount]);
[person release];
这次的打印结果为
2019-08-27 09:12:45.362995+0800 MRCManager[10928:615055] retainCount ----- 1
2019-08-27 09:12:45.363226+0800 MRCManager[10928:615055] -[CLPerson dealloc]
可以看到，person走了dealloc方法，也就是成功被释放了，原因就是通过release方法，使得自身的引用计数-1，1 - 1 = 0，然后系统便依据该引用计数的值将person释放。OC的内存管理其实原理很简单。
我们知道，Mac命令行项目，main函数时从上至下，线性执行，走到return 0，整个程序就退出结束了，因此像我们案例中的情景，很容易判断该何时对对象进行release操作。
在我们常用的iOS项目里面，由于加入了RunLoop，程序会在main函数里面一直循环，直到崩溃，或者手动关闭app。因此当一个对象被创建了之后，它什么时间会被使用，是很难确定的。如果不调用release，那么可以保证任何时间使用对象都是安全的，但是带来的问题便是，当对象不再使用之后，它便会一直存留在内存里面，不被释放，这就是我们常说的 【内存泄漏】。
为此，苹果为我们提供了autorelease，在每次创建对象的时候调用
CLPerson *person = [[[CLPerson alloc] init] autorelease];
这样，无需我们手动调用[person release];，系统会在某个合适的时间，自动对person进行release操作，这个“合适的时间”暂且理解成@autoreleasepool {}大括号结束的时候。
#import 上述案例仅仅针对一个对象这种简单情况来讨论。在iOS实际项目中，往往对象与对象之间是有很多关联的。我们继续给上面的代码添加一个CLCat对象
#import 如果CLPerson想拥有CLCat，则需要对其作如下调整
#import 这样就可以通过setCat方法，把CLCat对象设置到CLPerson的_cat成员变量上（拥有）；通过cat方法拿到成员变量_cat（获取）。也就是说CLPerson对象可以通过_cat指针操纵一个CLCat对象了。
int main(int argc, const char * argv[]) {
@autoreleasepool {
CLCat *cat = [[CLCat alloc] init];
CLPerson *person = [[CLPerson alloc] init];
[person setCat:cat];
[person.cat run];
[cat release];
[person release];
}
return 0;
}
***************** 打印结果 ****************
2019-08-27 10:22:11.086033+0800 MRCManager[11054:643966] -[CLCat run]
2019-08-27 10:22:11.086283+0800 MRCManager[11054:643966] -[CLCat dealloc]
2019-08-27 10:22:11.086294+0800 MRCManager[11054:643966] -[CLPerson dealloc]
Program ended with exit code: 0
从打印结果看上去，行得通。但是注意[person.cat run];是在 [cat release];之前。如果是下面这样
int main(int argc, const char * argv[]) {
@autoreleasepool {
CLCat *cat = [[CLCat alloc] init];
CLPerson *person = [[CLPerson alloc] init];
[person setCat:cat];
[cat release];
[person.cat run];
[person release];
}
return 0;
}
结果会是这样
报错的原因图中已经表明，所以，只需要确保[cat release];在[person.cat run];之后被调用即可。但是实际开发中， [person.cat run];何时被调用，是不确定的，并且次数也不确定，也就是说，我们无法确定[person.cat run];会于何时在何处被最后一次调用，因此就无法确定[cat release];到底该写在哪里。为了保证不出现EXC_BAD_ACCESS报错，可以干脆不写[cat release];，但这就带来了内存泄漏问题。
问题的本质就是CLPerson并没有真正拥有CLCat。所谓“真正”拥有，就是指只要CLPerson还在，那么CLCat就不应该被释放。为此，我们就可以这么做
#import "CLPerson.h"
@implementation CLPerson
-(void)setCat:(CLCat *)cat {
[_cat retain];//将引用计数+1
_cat = cat;
}
-(CLCat *)cat {
return _cat;
}
-(void)dealloc {
//自己即将被释放，不再需要cat了
[_cat release];
_cat = nil;
[super dealloc];
NSLog(@"%s",__func__);
}
@end
这样即使有多个CLPerson对象在使用CLCat，也不会出问题了
int main(int argc, const char * argv[]) {
@autoreleasepool {
//RC+1
CLCat *cat = [[CLCat alloc] init];
CLPerson *person = [[CLPerson alloc] init];
CLPerson *person2 = [[CLPerson alloc] init];
//内部 RC+1(setCat) --> RC-1(dealloc)
[person setCat:cat];
//内部 RC+1(setCat) --> RC-1(dealloc)
[person2 setCat:cat];
//RC-1，为了对应上面的[CLCat alloc]
[cat release];
[person.cat run];
[person2.cat run];
[person release];
[person2 release];
}
return 0;
}
从CLCat的retainCount变化过程可判断，最后它一定会变成0，不影响CLCat实例对象的释放，同时，也保证了CLCat的retainCount一定是在最后一个CLPerson实例对象释放之前（意味着CLCat不再被需要了，可以被释放了）被变成0，成功释放。运行结果也可以验证
2019-08-27 10:55:41.799859+0800 MRCManager[11120:657618] -[CLCat run]
2019-08-27 10:55:41.800096+0800 MRCManager[11120:657618] -[CLCat run]
2019-08-27 10:55:41.800111+0800 MRCManager[11120:657618] -[CLPerson dealloc]
2019-08-27 10:55:41.800117+0800 MRCManager[11120:657618] -[CLCat dealloc]
2019-08-27 10:55:41.800123+0800 MRCManager[11120:657618] -[CLPerson dealloc]
Program ended with exit code: 0
总的来说，手动管理内存的原则就是：保持实例对象的retainCount平衡，有+1，就有对应的-1，保证最终会变成0，实例对象可以被成功释放。
到目前为止，上面对setCat方法的处理，仍然不够完善。接下来我们继续讨论一下相关细节。 首先看下面的场景
int main(int argc, const char * argv[]) {
@autoreleasepool {
//person_rc + 1 = 1
CLPerson *person = [[CLPerson alloc] init];
//cat1_rc + 1 = 1
CLCat *cat1 = [[CLCat alloc] init];
//cat2_rc + 1 = 1
CLCat *cat2 = [[CLCat alloc] init];
//cat1_rc + 1 = 2
[person setCat:cat1];
//cat2_rc + 1 = 2
[person setCat:cat2];
//cat1_rc - 1 = 1
[cat1 release];
//cat2_rc - 1 = 1
[cat2 release];
//cat2_rc - 1 = 0
//person_rc - 1 = 0
[person release];
}
return 0;
}
**************** 打印结果 ****************
2019-08-27 11:23:20.185060+0800 MRCManager[11164:667802] -[CLCat dealloc]
2019-08-27 11:23:20.185318+0800 MRCManager[11164:667802] -[CLPerson dealloc]
Program ended with exit code: 0
打印结果显示，cat1产生了内存泄漏。根据代码注释里对各对象retainCount的跟踪，可以看出，是因为person在setCat方法里设置cat2为成员变量的时候，造成了cat1最终少进行了一次release，从而导致被泄漏。因此需要对setCat方法调整如下即可
-(void)setCat:(CLCat *)cat {
[_cat release];//将之前_cat所指向的对象引用计数-1，不在持有
[cat retain];//将传进来的对象引用计数+1，保证持有
_cat = cat;
}
上面我们解决了用不同CLCat对象进行setCat设置所产生的问题。接下来我们还需要看看用同一个CLCat对象进行setCat设置是否安全，代码如下
int main(int argc, const char * argv[]) {
@autoreleasepool {
//person_rc + 1 = 1
CLPerson *person = [[CLPerson alloc] init];
//cat_rc + 1 = 1
CLCat *cat = [[CLCat alloc] init];
//cat_rc + 1 = 2
[person setCat:cat];
//cat_rc - 1 = 1
[cat release];
[person setCat:cat];
[person release];
}
return 0;
}
上述代码可以安全走到下图所示的断点处
我们继续执行，就会在setCat方法里看到如下报错
可以看到[cat retain]报了EXC_BAD_ACCESS错误，说明cat此时已经被释放了。我们来分析一下，进入此方法是，cat对象的retainCount是1，当再次把cat对象传setCat方法是，由于person的_cat指向的也是cat，因此[_cat release]实际上就会导致cat的retainCount-1，也就是1-1=0，所以cat被系统释放。因此后面的代码再次使用[cat retain]便造成了野指针错误。因此解决办法是需要对传如的cat对象判断一下，如果等于当前_cat，就不需要执行引用计数的操作了，修改代码如下
-(void)setCat:(CLCat *)cat {
if (cat != _cat) {//只有当传进来的对象跟当前对象不同，才需要进行后面的操作
[_cat release];//将之前_cat所指向的对象引用计数-1，不在持有
[cat retain];//将传进来的对象引用计数+1，保证持有
_cat = cat;
}
}
这样，对于setCat方法的处理放啊就完善了。下面我贴一份完整的代码供参考
******************* CLPerson.h ******************
#import 对于非OC对象类型的成员变量，就不需要考虑内存管理的问题了，例如
@interface CLPerson : NSObject
{
int _age;
}
-(void)setAge:(int)age ;
-(int)age;
@end
@implementation CLPerson
-(void)setAge:(int)age {
_age = age;
}
-(int)age {
return _age;
}
@end
上面过程中，包含了非ARC时代进行手动内存管理的全部核心点。后来，随着Xcode的逐步发展，编译器自动帮我们生成了很多代码，让我的代码书写更加简洁。
编译器的进化
(1)@property + @synthesize
@property (nonatomic, retain) cat;的作用：自动声明getter、setter方法-(void)setCat:(CLCat *)age ; -(CLCat *)cat;
@synthesize cat = _cat;的作用：
- 为属性
cat生成成员变量_cat{ CLCat *_cat; }
- 自动生成
getter、setter方法的实现-(void)setCat:(CLCat *)cat { if (cat != _cat) { [_cat release]; [cat retain]; _cat = cat; } } -(CLCat *)cat { return _cat; }
(2)@property + @synthesize
后来苹果更进一步，连
@synthesize都不需要我们写了，一个@property搞定
- 成员变量的创建
getter、setter方法声明getter、setter方法实现
但是需要注意的是，@property并不帮我做dealloc里面的处理（对不需要使用的成员变量进行释放），因此dealloc方法还是需要我们手动去写的。
其实进入了ARC时代，iOS的内存管理底层机制并没有变化，只不过很多内存管理的代码ARC（编译器）自动替我们写好而已。好了，上古时期的MRC手动内存管理就介绍到这里。