内存管理剖析（一）—MRC时代的手动内存管理

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 <Foundation/Foundation.h>
#import "CLPerson.h"
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        CLPerson *person = [[CLPerson alloc] init];
        NSLog(@"retainCount ----- %zd",[person retainCount]);
        
    }
    return 0;
}

//*********  CLPerson.h   ************
#import <Foundation/Foundation.h>

@interface CLPerson : NSObject

@end

//*********  CLPerson.m   ************
#import "CLPerson.h"

@implementation CLPerson
-(void)dealloc {
    [super dealloc];
    NSLog(@"%s",__func__);
}
@end

我们从在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 <Foundation/Foundation.h>
#import "CLPerson.h"
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        CLPerson *person = [[[CLPerson alloc] init] autorelease];
        CLPerson *person2 = [[[CLPerson alloc] init] autorelease];
        NSLog(@" @autoreleasepool即将结束");
    }
    NSLog(@" @autoreleasepool已经结束");
    return 0;
}

//********************** 打印信息  *******************
2019-08-27 09:40:29.388495+0800 MRCManager[10970:625654]  @autoreleasepool即将结束
2019-08-27 09:40:29.388727+0800 MRCManager[10970:625654] -[CLPerson dealloc]
2019-08-27 09:40:29.388736+0800 MRCManager[10970:625654] -[CLPerson dealloc]
2019-08-27 09:40:29.388756+0800 MRCManager[10970:625654]  @autoreleasepool已经结束
Program ended with exit code: 0

上述案例仅仅针对一个对象这种简单情况来讨论。在iOS实际项目中，往往对象与对象之间是有很多关联的。我们继续给上面的代码添加一个CLCat对象

#import <Foundation/Foundation.h>

@interface CLCat : NSObject
-(void)run;
@end

***************************************************

#import "CLCat.h"

@implementation CLCat
-(void)run {
    NSLog(@"%s",__func__);
}

-(void)dealloc {
    [super dealloc];
    NSLog(@"%s",__func__);
}
@end

如果CLPerson想拥有CLCat，则需要对其作如下调整

#import <Foundation/Foundation.h>
#import "CLCat.h"
@interface CLPerson : NSObject
{
    CLCat *_cat;
}
//拥有猫
-(void)setCat:(CLCat *)cat;
//获取猫
-(CLCat *)cat;
@end

***************************************************


#import "CLPerson.h"
@implementation CLPerson

-(void)setCat:(CLCat *)cat {
    _cat = cat;
}

-(CLCat *)cat {
    return _cat;
}

-(void)dealloc {
    [super dealloc];
    NSLog(@"%s",__func__);
}

@end

这样就可以通过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 <Foundation/Foundation.h>
#import "CLCat.h"

@interface CLPerson : NSObject
{
    CLCat *_cat;
    int _age;
}
//拥有猫
-(void)setCat:(CLCat *)cat;
//获取猫
-(CLCat *)cat;
@end

******************* CLPerson.m ******************


#import "CLPerson.h"

@implementation CLPerson
-(void)setCat:(CLCat *)cat {
    if (cat != _cat) {//只有当传进来的对象跟当前对象不同，才需要进行后面的操作
        [_cat release];//将之前_cat所指向的对象引用计数-1，不在持有
        [cat retain];//将传进来的对象引用计数+1，保证持有
        _cat = cat;
    }
    
}

-(CLCat *)cat {
    
    return _cat;
}


-(void)dealloc {
    //自己即将被释放，不再需要cat了
//    [_cat release];
//    _cat = nil;
    self.cat = nil;//相当于上面两句的效果
    
    [super dealloc];
    NSLog(@"%s",__func__);
}
@end


*****************CLCat.h ***************
#import <Foundation/Foundation.h>
@interface CLCat : NSObject
-(void)run;
@end

*****************CLCat.m ***************
#import "CLCat.h"
@implementation CLCat
-(void)run {
    NSLog(@"%s",__func__);
}

-(void)dealloc {
    [super dealloc];
    NSLog(@"%s",__func__);
}
@end

对于非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方法还是需要我们手动去写的。

**好了，上古时期的MRC手动内存管理就介绍到这里。

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 213,928评论 6赞 493
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 91,192评论 3赞 387
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 159,468评论 0赞 349
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 57,186评论 1赞 286
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 66,295评论 6赞 386
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 50,374评论 1赞 292
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 39,403评论 3赞 412
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 38,186评论 0赞 269
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 44,610评论 1赞 306
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,906评论 2赞 328
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 39,075评论 1赞 341
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 34,755评论 4赞 337
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 40,393评论 3赞 320
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 31,079评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,313评论 1赞 267
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 46,934评论 2赞 365
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 43,963评论 2赞 351