黑马程序员------OC 内存管理MRC和autorelease pool

 ------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

内存管理

1.内存管理概念

      由于移动设备的内存机器有限 所以每个被占用的内存也是有限的。不用的内存是余姚回收的，否则程序会崩溃

 

    oc 管理内存的范围： 管理任何继承NSObject的对象，对其他的基本数据类型无效

      基本数据类型数据占用的存储空间是固定的 一般存储在栈区。

      对象类型是程序运行过程中动态分配的，存储在堆区，内存管理主要是 对堆区的对象 的内存管理

    oc内存管理分类：MRC(手动管理内存) ARC(自动管理内存)

  2.引用计数器

       引用计数器是用来保存当前对象有几个东西在使用它(数字)，在对象里有一块专门的空间大小为8个字节来存储

       引用计数器的作用 : 用来判断对象是否应该回收(如果对象不等于nil 当引用计数器为0，此时要回收对象的内存空间)

        引用计数器的操作

           retain 使得引用计数器 +1

           release 使得引用计数器 -1

           retainCount 得到引用计数器的值

    如果一个对象被释放的时候，就会调用“临终遗言”（dealloc方法）

    注意：

         1）dealloc 方法是NSObject 的，一般我们要重写dealloc方法

         2）在dealloc 方法内部，要调用[super dealloc];

 

 #import <Foundation/Foundation.h>

@interface Person : NSObject

@end
#import "Person.h"

@implementation Person
//dealloc方法，是对象临终的遗言方法
//对象被销毁时，会默认的调用该方法
//dealloc方法 是系统根据引用计数器的值，自动调用的
- (void)dealloc{
  //先释放子类自己的空间
    NSLog(@"person dealloc");
   //再释放父类的
    [super dealloc];
}

@end
#import <Foundation/Foundation.h>
#import "Person.h"
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        //用person实例画一个对象
        Person *p =[[Person alloc] init ];
        //查看有几个拥有者
        NSUInteger count =[p retainCount];
        
        NSLog(@"count = %lu",count);//count =1
        
        [p release];//对象要被回收。 使用release 给引用计数器-1
                     //这时retainCount 为0 对象被回收掉用dealloc 方法
        
        
    }
    return 0;

 

注意:永远不要直接通过对象调用dealloc方法。对象一旦被回收不可再用，坚持使用会使程序崩溃

  3.内存管理的原则

      如果对象有人使用，就不应该回收

      如果你想使用这个对象，应该让这个对象retain  一次

      如果你不想使用这个对象你应该然然这个对象 release  一次

       谁创建谁 release 

       谁retain 谁release 

 

#import <Foundation/Foundation.h>

@interface Dog : NSObject
-(void)eat;
@end
#import "Dog.h"

@implementation Dog
-(void)eat{
    NSLog(@"狗在吃东西");
}

@end
#import <Foundation/Foundation.h>
#import "Dog.h"
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        //创建 new  alloc init  copy
        Dog *bigYellowDog =[[Dog alloc] init];
        
        Dog*jb =[bigYellowDog retain];//  引用计数器+1 当前值为2
          [bigYellowDog release]; //谁retain 谁release
        //只有保证谁创建谁release，才能保证对象被回收
        [bigYellowDog release];
      
        
        Dog *byd = [[Dog alloc] init];
        [byd eat];
        //如果一个对象已经被释放了，这个对象就称之为僵尸对象
        [byd release];
        //这句话佛人情况下不会报错
        //如果要报错，要开启僵尸对象检测，
         //byd指针也就是野指针
        [bye eat]
        
        [byd retain];//byd已经是僵尸对象了 不能复生
    }
    return 0;
}

 

4.内存管的研究内容

   1）野指针  定义的指针变量没有初始化  指向的空间已经被释放

   2）内存泄露

     { Person *p=[Person new]; }

   p 在栈区   [Person new]；在堆区 

   如果栈区的已经被释放了，而堆区的空间还没有被释放，堆区的空间就被泄露了

注意： p=nil 空指针 没有志向任何店东西的指针 ，给空指针发送消息不会报错。

5.单个对象的内存管理

#import <Foundation/Foundation.h>

@interface Dog : NSObject
- (BOOL)compareColorWithOther:(Dog*)dog;
@end
#import "Dog.h"

@implementation Dog
- (BOOL)compareColorWithOther:(Dog*)dog{
    
    [dog retain];//让传入的对象的引用计数器+1
    return YES ;
}@end
#import <Foundation/Foundation.h>
#import "Dog.h"
int main(int argc, const char * argv[]) {
    @autoreleasepool {

        Dog * d= [[Dog alloc] init]; //1
        
        [d release];//1--》0
        //给空指针发送任何消息，都没有效果
        //[nil run];
        //避免使用僵尸对象方法是，对象释放了以后，给对象赋值为nil
        //d =nil; //nil  给对象赋值 ， Nil类对象
       // [d run];
        //单个内存泄露问题
          //内存泄露情况1  没有错遵守内存故那里原则,创建完之后没有release；
        //Dog *d = [[Dog alloc] init];
        //内存泄露情况2.没有遵守内存管理原则
        Dog *d = [[Dog alloc] init];//1
        [d retain];//2
        [d release];
        //retain 完了之后额米有release
        //内存泄露问题3 不当的使用nil
        //Dog *d =[[Dog alloc] init];//1
        //d=nil;
        //[d eat]
        //[d release]
           //内存泄露情况4 在方法中对传入的对象进行了retain；
        Dog* d =[[Dog alloc] init];//1
        //对象依然被泄露了
        [d compareWhithOther:d];//2
        [d release];
    }
    return 0;
}

 

6.多对象内存管理

   set 方法内存管理

   原则： 如果在一个类中，有其他类的对象（关联关系）

        set方法书写的时候要判断是否是同一个对象，release 旧值，retain新值。

            - (void)setDog:(Dog*)dog{

                //判断对象是否是原对象

                if(_dog =dog){

                    //release 旧值

                    [_dog release];

                  //retain 新值 ，并且赋值给实例变量

                _dog =[dog retain];

            }

        }

#import <Foundation/Foundation.h>

@interface Car : NSObject
@property int speed;
-(void)run;
@end
#import "Car.h"

@implementation Car
- (void)dealloc{
    NSLog(@"车被销毁了%d",_speed);
    
    [super dealloc];
    
}
-(void)run{
    NSLog(@"车以%d 的速度奔向拉萨",_speed);
}

@end

#import <Foundation/Foundation.h>
@class Car;


@interface Person : NSObject
{
    Car *_car;
}
@property (assign)NSString * name;
//拥有一辆车

-(void)goLasa;
- (void)setCar:(Car *)car;
-(instancetype)initWithName:(NSString*)name;
@end
#import "Person.h"
#import "Car.h"

@implementation Person
-(instancetype)initWithName:(NSString*)name{
    if (self =[super init]) {
        _name = name;
    }
    
    return self;

}
-(void)dealloc{
    
    [_car release ];
    NSLog(@"人已经挂了");
    //让父类释放
    [super dealloc];

}
-(void)goLasa{
    [_car run];
}
- (void)setCar:(Car *)car{
    //如果是_car == car 这是同一对象 ，那就不需要relaese
    if (_car != car) {
        [_car release];
        _car =[car retain];
    }
}
@end

#import <Foundation/Foundation.h>
#import "Person.h"
#import "Car.h"



int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Person *p =[[Person alloc] initWithName:@"凤姐"];
        
        Car * bmw =[[Car alloc] init];
        bmw.speed =200;
        //给凤姐一辆车
        [p setCar:bmw];
        //去拉萨
        [p goLasa];
         [bmw release];
        
          [p goLasa];
         //创建新车
        Car *byd =[Car new];
         byd.speed =100;
        //凤姐给新车
        [p setCar:byd];
        [p goLasa];
          [byd release];
        
          [p release];
       
       
        
        
        
}
    return 0;
}
      }

  7.@property参数

      原子性 atomic 对属性加锁，多线程下线程安全，默认值

            nonatomic 对属性不加锁 多线程下不安全，但是速度快

      读写性 readwrite 生成getter、setter 默认值

            readonly  只生成getter方法

      set方法处理（内存管理）

                assign  直接赋值 默认值

                retain   先release原来的值，再retain新值

                  copy   先release原来的值，再copy新值

    什么时候使用retain 

    在一个类中有关联其他对象的时候，这个时候的@property (nonatomic,retain)

     什么时候使用assign  实例变量是最基本的数据的时候

    //这个时候会生成 set和get方法的声明和实现

      readobnly 只会生成 get方法。默认的时readwrite

    @property (nonatomic,assign)int Num;

    

    替换set方法的名称 @property(nonatomic ,setter=isVip:)

         [p setVip: ispYES];//--->[p isVip:YES]

    替换个get方法的名称 @propery(nonatomic,setter=isVip:,getter=isVip);

    @class 的使用

  可以简单的引用一个类 

    @class Dog //类的引入

     仅仅是告诉编译器：Dog是一个类；并不会包含Dog这个类的所有内容

    

    具体使用  在.h文件中使用@class引用一个类；在.m文件中使用#import包含这个类的.h文件

    #import作用：要把映入的头文件内容拷贝到写#import处 ，如果Person.h文件内容发生变化，此时的所有的Person.h这个头文件的类都要重新编译

   使用格式  @class  类名

        @clss xxx  

      含义：是告诉编译器 xxx是一个类 至于有那些属性和方法此处不去检测

      好处是：如果xxx文件内容发生了改变，而不需要重新编译

    @class 可以解决循环引用的问题

        

      #import 和@class的区别

     作用上区别：#import会包含引用类的所有信息（内容），包括引用类的变量和方法

               @class仅仅是告诉编译器有这么一个类，具体这个类例有什么信息，完全不知道

     效率上的区别 

       如果有上百的文件都#import了同一个文件，或者这些文件一次被#import，那么一旦最开始的问价稍有改动，后面引用到这个文件的所有类都需要重新编译一边，编译效率非常低

 8.autorelease基本使用

       自动释放池 

    1）在ios程序运行过程中，会创建无数个池子，这些池子都是以栈结构(先进后出)存在的。

    2）当一个对象调用autorelease时，会将这个对象放到位于栈顶的释放池中

   基本方法

     1）会将对象放到一个自动释放放池中

     2) 当自动释放池子被销毁时，会对池子里的所有对象做一次release

     3)会返回对象本身

     4）在调用完autorelease方法后，对象的计数器不收影响（销毁时影响）

  

     自动释放池的使用

     1）创建自动释放池

        @autoreleasepool{

       }

     2）加入释放池

           在自动释放池中

          [对象 autorelease];

      Person *p = [Person new ];

     //创建自动释放池

     @autoreleasepool {//自动释放池开始

     [p autorelease]//把对象放到自动释放池 ,引用计数器不会变化

 

       }//自动释放池结束 p对象被回收

 

    好处 （1）不再需要关心对象释放的时间  （2）不需要关心社么时候调用release

     

    autorelease是什么原理

      autorelease实际上只是把release的调用延迟了，对每个Autorelease ，系统只是把该Object放入了当前的autorelease pool中，当该pool被释放时，该pool中的所有Object会被调用release。

    autorelease 的使用注意

    1）并不是所有的放到自动释放池中的代码，产生的对象就会自动释放，如果需要释放，必须加入到自动释放池

        Person *p =[[Person new] autorelease]; 

       我们只需要在自动释放池代码块中调用autorelease就可以把对象加入到自动释放池

   2）如果对象调用；autorelease 但是，调用autorelease的时候，没有在任何一个自动释放池中，此时该对象也不会被加入到自动释放池

    自动释放池的栈结构(数据结构)，和内存的栈区是不一样的 对象在 位于栈顶的释放池

 

 自动释放池的应用

      NSString * str = [NSString stringWithFormat:@"xxxx"];

        NSArray * array =[NSArray array]

    Person 类方法：

     帮我们自动创建对象，并且管理对象的内存（加入到自动释放池）

    Person *p =[Person person];

    1)创建一个对象 p

    2）用完之后，系统把对象释放掉p

    Person *p =[[Person alloc] init];

       p autorelease;

     +(id)person{

         //创建对象

        return [[[Person alloc] init] autorelease]; //返回对象空间

          //能够帮我们把对象给加入到自动释放池

     }

快速创建一个学生类初始化年龄
#import <Foundation/Foundation.h>

@interface Student : NSObject

@property (nonatomic,assign) int age;

- (instancetype)initWithAge:(int) age;

+ (instancetype)studentWithAge:(int)age;
@end
#import "Student.h"

@implementation Student
//重写构造方法给年龄初始化
- (instancetype)initWithAge:(int) age{
  //初始化父类 判断有没有成功
    if (self = [super init]) {
     //初始化子类。赋值年龄。
        _age =age;
    }
    return self;
}

+ (instancetype)studentWithAge:(int)age{


    return    [[[Student alloc] initWithAge:age]  autorelease];
}

-(void)dealloc{

    NSLog(@"Student dealloc");
    [super dealloc];
}

@end

#import <Foundation/Foundation.h>
#import "Student.h"
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        Student *stu =[[Student alloc] initWithAge:18];
        NSLog(@"stu.age = %d",stu.age);
        [stu release];
        
        //快速创建一个对象 给年龄初始化
         //1)定义类方法
        //2）类方法有参数，传递一个年龄
        Student *stu1 =[Student  studentWithAge:18];
        NSLog(@"stu1.age = %d",stu1.age);
    }
    return 0;
}