iOS内存管理系列1之 内存管理实现原理的深入分析

关于iOS的内存管理机制其实网上有很多这方面的文章可以学习，大家都知道是基于自动引用计数方式来管理的，至于什么是自动引用计数今天在这里我就不过多的赘述了，不懂的童鞋可以自行google下。今天我们主要讲讲iOS内存管理的一些思考方式：

1.自己生成的对象，自己所持有

所谓的自己生成的对象就是使用alloc,new,copy,mutableCopy方法生成并持有的对象，或者用retain方法持有的对象，或者以alloc/new/copy/mutableCopy这些关键字开头的方法生成的对象，一旦不再需要就要调用release方法进行释放，如：

{
    //调用alloc方法，所以属于自己生成并持有对象,自己的引用计数加1
    id  obj = [[NSObject alloc] init];
    
}
//一但出了作用域，强引用失效，属性obj被释放，因为NSObject对像的持有者不存在，所以NSObject对象也被废弃掉

2.非自己生成的对象自己也能持有

如：

{
   //在NSMutableArray类的array方法的源码中生成的对象，因为非自己生成，所以自己无法持有，如果想让自己持有的话需要retain一下，即在下面加一行[obj retain]
    id  obj = [NSMutableArray array];
    [obj retain];//变为自己持有
}

3.不再需要自己持有的对象时需要释放掉

如果是自己持有的对象，在不需要使用的时候，本着节约内存的原则需要持有者释放掉，

id obj = [[NSObject alloc] init];
[obj release];
//对象一经释放就不可以访问

如果要用某个方法生成对象，并将其返还给该方法的调用者，比如：

-(id)allocObject{

    //自己生成并持有对象
    id obj = [[NSObject alloc] init];
    
    //自己持有对象
    return obj;

}

如上所示，原封不动的返回用alloc方法生成并持有的对象，就能让调用方也持有该对象，因为allocObject这个名称是符合前面所说的命名规则的。

4.无法释放非自己持有的对象

如果不是用上面所提到的方法生成的对象，如果在应用程序中释放的话就会造成崩溃。

id obj = [[NSObject alloc] init];
    //释放对象
    [obj release];
    
    /*
     释放之后再次释放非自己持有的对象，应用程序崩溃.
     崩溃情况：
     1，再度废弃已经废弃了的对象时崩溃
     2，访问已经废弃了的对象时崩溃
     
     */
    [obj release];

alloc/retain/release/dealloc 的实现

因为都知道Object-C是不开源的，所以我们很难通过源码看到里面的实现，但是有个Cocoa的互换框架GNUstep，这俩框架的实现基本上大同小异，GNUstep是开源的，你可以在这里下来下载GNUstep查看。

GNUstep/modules/core/base/base/Source/NSObject.m alloc

-(id)alloc{
    return [self allocWithZone:NSDefaultMallocZone()];
}
+(id)allocWithZone:(struct _NSZone *)zone{
    return  NSAllocateObject(self, 0, zone);
}

通过allocWithZone:类方法调用NSAllocateObject函数分配了对象，然后看看NSAllocateObject函数

struct obj_layout{
    
    NSUInteger retained;
}

inline id
NSAllocatedObject(Class aClass,NSUIntege extraBytes,NSZone *zone){

    int size = "计算容纳对象所需内存大小";
    id new = NSZoneMalloc(zone, size);
    memset(new, 0, size);
    new = (id) & ((struct obj_layout *) new)[1];
}

NSAllocatedObject函数通过调用NSZoneMalloc 函数来分配存放对象所需的内存空间，之后将该内存空间置0；最后返回作为对象而使用的指针。

alloc 类方法用结构体obj_layout里面的retained整数来保存引用计数，并将其写入对象内存头部，该对象内存块全部置0后返回

我们知道对象的引用计数可通过retainCount对象方法取得:

NSLog(@"retainCount = %d",[obj retainCount]);

retainCount的GNU源码如下：

-(NSInteger)retainCount{
    return NSExtraRefCount(self) +1;
}
inline NSUInteger
NSExtraRefCount(id anObject)
{
    return ((struct obj_layout *) anObject)[-1].retained;
}

由对象寻址找到对象内存头部，从而访问其中的retained变量

GNUstep/modules/core/base/Source/NSObject.m 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;
    }
}

当retained变量大于0时减1，等于0时调用dealloc 实例方法，废弃对象。下面是废弃对象时所调用的deallo方法的实现。

GNUstep/modules/core/base/Source/NSObject.m dealloc

-(void)dealloc{
    NSDeallocateObject(self);
}
inline void
NSDeallocateObject(id anobject){
    struct obj_layout *o = &((struct obj_layout *) anobject)[-1];
    free(o);
}

autorelease

GNUstep/modules/core/base/Source/NSObject.m autorelease

-(id)autorelease{

    [NSAutoreleasePool addObject:self];
}

autorelease实例方法的本质就是调用NSAutoreleasePool对象的addObject方法。
接下来看下NSAutoreleasePool类的实现，由于NSAutoreleasePool类的源码比较复杂，所以我们假想一个简化的源代码进行说明。
GNUstep/modules/core/base/Source/NSObject.m NSAutoreleasePool

-(void)addObject:(id)anObject{
    NSAutoreleasePool *pool = 取得正在使用的NSAutoreleasePool对象;
    if (pool !=nil) {
        [pool addObject:anObject];
    }else{
        NSLog(@"NSAutoreleasePool对象非存在状态下调用autorelease");
    }
}

addObject类方法调用正在使用的NSAutoreleasePool对象的addObject实例方法。以下源码中，被赋予pool变量的即为正在使用的NSAutoreleasePool对象

-(void)addObject:(id)anObject{
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
    id obj = [[NSObject alloc] init];
    [obj autorelease];
}

如果嵌套生成或持有NSAutoreleasePool对象，就会使用最内侧的对象。下例中，pool12为正在使用的NSAutoreleasePool对象

  NSAutoreleasePool *pool0 = [[NSAutoreleasePool alloc] init];
          NSAutoreleasePool *pool1 = [[NSAutoreleasePool alloc] init];
              NSAutoreleasePool *pool2 = [[NSAutoreleasePool alloc] init];
     id obj = [[NSObject alloc] init];
     [obj autorelease];
             [pool0 drain];
        [pool1 drain];
   [pool2 drain];

下面看一下addObject实例方法的实现：
GNUstep/modules/core/base/Source/NSAutoreleasePool.m addObject

-(void)addObject:(id)anObject{

    [[NSMutableArray array] addObject:anObject];
}

实际的GNUstep实现使用的是连接列表，这同在NSMutableArray对象中追加对象参数是一样的
如果调用NSObject类的autorelease实例方法，该对象将被追加到正在使用的NSAutoreleasePool对象中的数组里

[pool drain];

下面为通过drain实例方法废弃正在使用的NSAutoreleasePool对象的过程。
GNUstep/modules/core/base/Source/NSAutoreleasePool.m drain

-(void)drain{
    [self dealloc];
}
-(void)dealloc{
    [self emptyPool];
    [array release];
}
-(void)emptyPool{
    for (id obj in array) {
        [obj release];
    }
}

以上的实现是GNUstep里面的实现，iOS里面的实现基本与之类似