Objective-C内存管理

1.内存管理中的基本问题

　　1.1为什么要进行内存管理    分配在堆空间中的对象 需要手动去释放

回顾堆栈的区别                                                                          生命周期 

栈空间    函数 函数中局部变量             　　　　　　调用函数压栈    函数调用结束 释放　　

数据段    静态变量  全局变量                　　　　　　程序开始             程序结束 释放

堆:                malloc  alloc                                程序猿手动释放 free() release

 

　　1.2内存管理的定义  

内存管理就是确保开辟的堆空间被正确的释放。

内存管理中的问题:

1.内存泄露  堆空间没有释放

2. 内存崩溃 野指针 (过早释放：使用已经释放的空间     

重复释放：重复释放同一个空间)

 

　　1.3 C语言内存管理的缺陷

1 释放一个堆 ,必须保证所有使用堆的指针结束使用,避免(提前释放);

2  释放一个指针,确保指向同一个堆的指针,只有一个被释放,避免(重复释放);

3 模块化分工编程,不易明确谁来释放

4 多线程操作,不能确定哪个线程最后结束

 

　　1.4 OC内存管理的基本原则

1.对象在完成创建的同时，内部会自动创建一个引用计数器，这个计数器，是系统用来判断是否回收对象的唯一依据，当我们的引用计数retainCount ＝ 0的时候，系统会毫不犹豫回收当前对象

 2.[对象 retain]   reatinCount + 1 ，返回self

 3.[对象 release]  reatinCount - 1

 4.我们的引用计数retainCount ＝ 0时  对象就被销毁了

  5.dealloc函数，当一个对象要被销毁的时候，系统会自动调用dealloc函数，通知对象你将要被销毁

  内存管理原则(配对原则):只要出现了 new,alloc,retain,就一定配对出现一个release,autorelease

        Person * p = [[Person alloc] init];
        NSLog(@"%lu",p.retainCount);
//        [p retain];
        Person * q = [p retain];
        NSLog(@"%lu",q.retainCount);
        
        [p release];
        NSLog(@"%lu",p.retainCount);
        
        [q release];
        NSLog(@"%lu",p.retainCount);
        [p run];

创建一个Person类  一个p指针指向创建的对象    创建完成之后 计数器为1   创建一个q指针指向p原本指的对象 计数器+1为2 

[p release] 计数器-1   [q release] 计数器再-1 此时对象释放    

- (void)dealloc {
    NSLog(@"人被释放了");
    [super dealloc];
}

类中重写dealloc方法 则会输出 人被释放了  若开启僵尸对象检测 则[p run]报错

 

 

// 为什么最后不为0？

最后一次输出，引用计数没有变成0.

这是为什么呢？

因为该对象的内存已经被回收，而我们向一个已经被回收的对象发了一个retainCount消息，所以它的输出结果应该是不确定的，如果该对象所占的内存被复用了，那么就有可能造成程序异常崩溃。

 

那为什么在这个对象被回收之后，这个不确定的值是1而不是0呢？这是因为当最后一次执行release时，系统知道马上就要回收内存了，就没有必要再将retainCount减1了，因为不管减不减1，该对象都肯定会被回收，而对象被回收后，它的所有的内存区域，包括retainCount值也变得没有意义。不将这个值从1变成0，可以减少一次内存操作，加速对象的回收。

 

2.单个对象的内存管理

    2.1.1 内存泄露的第一种情况

    Person * p = [[Person alloc] init];
    NSLog(@"%lu",p.retainCount);
    Person * q = [p retain];
    NSLog(@"%lu",q.retainCount);
    [p release];//引用两次需要两次release  少写一次都会内存泄露
    [q release];

　2.1.2内存泄露的第二种情况

    Person * p2 = [[Person alloc] init];
    NSLog(@"%lu",p2.retainCount);
    p2 = nil;
    [p2 release]; // [nil release]

释放前指向nil   然后release 之前的对象没有被释放

 

　　2.2.1 野指针的提前释放 

        Person * p = [[Person alloc] init];
        NSLog(@"%lu",p.retainCount);
        Person * q = [p retain];
        
        [p release];
       // p = nil;
        [q release];
        //q = nil;
        [p run]; // [nil run]  // nil 调用任何方法都不会报错

提前释放之后再用对象的方法 会形成提前释放的野指针

 

　　2.2.2野指针的重复释放

        Person * p = [[Person alloc] init];
        NSLog(@"%lu",p.retainCount);        
        [p release];
        [p release];
//重复释放 

释放之后 不可retain  无法起死回生 

 

3.多个对象的内存管理

        // 创建Person对象
        Person * p = [[Person alloc] init];
        // 创建Car对象
        Car * c = [[Car alloc] init];
        // 让人有一辆车
        [p setCar:c];
        [p drive];
        [c release];
        [p drive];
        // 只要p对象存在,就可以随意调用自己的方法
        [p release];

//Car类成员方法的实现以及dealloc的重写
- (void)dealloc {
    NSLog(@"dealloc 车被销毁了");
    [super dealloc];
}

- (void)run {
    NSLog(@"车跑起来了");
}

//Person类成员方法的实现以及dealloc方法的重写

- (void)setCar:(Car *)car {
    //在setCar的时候,让car的retainCount+1
    // 目的是保证p对象存在的时候,_car对象一定存在
    _car = [car retain];
}

- (Car *)car {
    return _car;
}

- (void)drive {
    [_car run];
}

- (void)dealloc {
    NSLog(@"dealloc 人被销毁了");
    // 保证p对象销毁的时候,他所持有的_car对象也被销毁,防止出现内存泄露
    [_car release];
    [super dealloc];
}

 　　set方法的内存管理  

若两次set方法的参数都为同一对象  那么会先把对象release一次之后再retain   但release之后就释放掉了  所以要判断参数是否和对象的成员相等

- (void)setCar:(Car *)car {
    //在setCar的时候,让car的retainCount+1
    // 目的是保证p对象存在的时候,_car对象一定存在
    
    // 如果调用 _car = car,并且_car的retainCount=1 的情况下会出现野指针问题
    if (_car != car) {
        // 第一次运行 [nil release]
        [_car release];
        _car = [car retain];
    }
    
}

set方法可以改写为如下所示。

 

4.@property的参数

// 1与内存管理相关的参数

// 默认是 assign

// retain 生成符合内存管理原则的set方法

// assign 直接赋值,不考虑内存管理(一般基本数据类型)

// 2 与多线程相关的代码

// notatomic 不生成与多线程相关的代码 默认 iOS开发中用这个

// atomic 生成与多线程相关的代码 mac开发中会用到

// 3 是否生成set与get方法

// readonly 只生成get方法

// readwrite 生成get与set方法 默认

// 没有只生成set方法的参数

// 4 set与get方法名称相关的参数

// setter 设置set方法的名字(有冒号);

// getter 设置get方法的名字

 

5.循环引用问题

Person类有Car类的属性

Car类也有Person类的属性 就成为循环引用  

 

.h文件中导入头文件应换成 @class 类名 的形式 

前向声明 告诉系统有这样一个类

.m文件中应导入头文件 调用类的成员方法

引用关系应该一强一弱  

#import <Foundation/Foundation.h>
#import "Person.h"
#import "Car.h"
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // p 1 car 1
        Person * p = [[Person alloc] init];
        Car * car = [[Car alloc] init];
        // p 1 car 2
        [p setCar:car];
        // car 2  p 1
        [car setPerson:p];
        // p 0 car 1
        [p release];      //难点总结：p release之后 计数count 变为0,此时调用 p 的 dealloc 函数，随之成员变量_car release
        // p 0  car 0
        
        [car release];
        
        
        
        
//        // p 1 car 1
//        Person * p = [[Person alloc] init];
//        Car * car = [[Car alloc] init];
//        // p 1 car 1
//        [p setCar:car];
//        // car 1 p 2
//        [car setPerson:p];
//        // p 1 car 1
//        [p release];
//        // p 0  car 0
//        [car release];
        
        
        
        
//        // p 1 car 1
//        Person * p = [[Person alloc] init];
//        Car * car = [[Car alloc] init];
//        // p 1 car 2
//        [p setCar:car];
//        // car 2 p 2
//        [car setPerson:p];
//        // p 1 car 2
//        [p release];
//        // p 1 car 1
//        [car release];        
       
    }
    return 0;
}

#import <Foundation/Foundation.h>
@class Car; // 前向声明 告诉系统有这样一个类
@interface Person : NSObject
@property (nonatomic,retain) Car * car;
@end

#import "Person.h"
#import "Car.h"
@implementation Person
- (void)dealloc {
    NSLog(@"person 被销毁了");
    [_car release];
    [super dealloc];
}
@end

#import <Foundation/Foundation.h>
@class Person;
@interface Car : NSObject
@property (nonatomic,assign) Person * person;
@end

#import "Car.h"
#import "Person.h"
@implementation Car
- (void)dealloc {
    NSLog(@"car 被销毁了");
//    [_person release]; 弱引用 所以没有这行
    [super dealloc];
}
@end

 

 

6.autorelease的基本原理  

autorelease   作用为延迟释放   

    @autoreleasepool {
        Person * p = [[Person alloc] init];
        //        [p release];// 立即减1
        [p autorelease]; // 延迟减1 把对象添加到最近的自动释放池
        NSLog(@"aaa");
    }// 自动调用 [pool drain]
   

也可以new一个NSAutoreleasePool对象      释放时调用[pool drain]方法  可以起到}的作用

    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
    // {
    Person * p = [[Person alloc] init];
    [p autorelease];
    //        [p retain];
    Person * q = [[Person alloc] init];
    [q autorelease];
    NSLog(@"aaa");
    // 给池子里每一个对象发送release方法
    [pool drain]; // [p release]
    // }
    NSLog(@"bbb");

 

    Person * p = [[Person alloc] init];
    // 自动释放池是可以随意创建的
    // 不管这个对象是在@autoreleasepool之内还是之外创建的,只要你在池子中调用了autorelease方法,那么这个对象就会被放入到池子中,随着池子的销毁而销毁
    // 创建一个自动释放池
    @autoreleasepool {
        [p autorelease];
        NSLog(@"aaa");
    }
    NSLog(@"bbb");

    Person * p = [[Person alloc] init];
    @autoreleasepool {
        [p autorelease];
    
        @autoreleasepool {
            [p autorelease];
            NSLog(@"aaa");
        }//此时已经释放
        NSLog(@"bbb");
    }

 

 

7. autorelease的应用 

    @autoreleasepool {
//        Chief * c = [[Chief alloc] init];
//        [c autorelease];
        Chief * chief = [Chief chief];
        
        Food * food = [chief foodByChief];
        NSLog(@"%@",food.name);
        
        NSLog(@"aaa");
    }
    NSLog(@"bbb");
    return 0;





+ (id)chief {
    id chief = [[self alloc] init];
    
    return [chief autorelease];
}

- (Food *)foodByChief {
    Food * food = [[Food alloc] init];
    food.name = @"辣条";
    return [food autorelease];
}

 

 

8. ARC的使用 

#import <Foundation/Foundation.h>
#import "Dog.h"
// __strong __weak

void testStrong()
{
    //只要有强指针指向一个对象,那么系统就不会回收该对象,只要没有强指针指向对象,系统立即回收该对象
    // 默认情况下所有的指针都是强指针类型
    // 在ARC中,不能调用retain release autorelease
    // 也不能显式调用[super dealloc]
    Dog * dog = [[Dog alloc] init];
    // 对象一
    NSLog(@"aaa");
    //
    Dog __weak * dog1 = [[Dog alloc] init]; // assign
    
    //        dog = nil;
    Dog * dog2 = [[Dog alloc] init];
    // 对象二
    dog = dog2;
    NSLog(@"%@ %@",dog,dog2);
}

void testWeak()
{
    Dog * dog = [[Dog alloc] init];
    
    Dog * __weak dog1 = dog;
    NSLog(@"%@ %@",dog,dog1);
    dog = nil;
    NSLog(@"%@ %@",dog,dog1);
    // 如果对于一个对象而言,这个对象既有强引用的指针,又有弱引用的指针,当强引用的指针不存在时,所有弱引用的指针会自动置空
}

void testAutoreleaseing()
{
    //
    Dog * dog = nil;
    Dog __autoreleasing * dog1 = nil
    ;
    
    @autoreleasepool {
        dog = [[Dog alloc] init];
        NSLog(@"dog---%@",dog);
        
        dog1 = [[Dog alloc] init];
        NSLog(@"dog1--%@",dog1);
        
    }
    NSLog(@"dog------%@",dog);
    NSLog(@"dog1------%@",dog1);
}

void testUnsafe_unretained()
{
    // __unsafe_unretained只要指向对象的指针至少有一个强引用存在,那么 __unsafe_unretained和__weak功能一样
    // 若没有强引用的指针后,__weak类型的指针会自动置空,而__unsafe_unretained类型的指针不会
    Dog __unsafe_unretained * dog = nil;
    {
        Dog * dog11 = [[Dog alloc] init];
        dog = dog11;
        dog11 = nil;
        NSLog(@"%@",dog);
    }
}


int main(int argc, const char * argv[]) {
    @autoreleasepool {
        testUnsafe_unretained();
        
    }
    return 0;
}

#import "Dog.h"

@implementation Dog
- (void)dealloc {
    NSLog(@"dog 被释放了");
    // 不能显式调用[super dealloc]
    // 不能调用release autorelease retain
    // 不能查看retainCount
//    [super dealloc];
}
@end

 

 

 

9.MRC与ARC的混编

 

Dog类为ARC     在MRC中运行时需要更改的设置

 

 

Car和Engine为MRC   在ARC中运行时需要更改的设置