黑马程序员-----OC学习之内存管理

内存管理：OC中继承了NSObject的对象存储在堆区无法自动回收；

1.作用范围：

任何继承了NSObject的对象,对其他基本数据类型（int、char、float、double、struct、enum等）无效；

2.原理：

每个对象内部都保存了一个与之相关联的整数,称为引用计数器；
当使用alloc、new或者copy创建一个对象时,对象的引用计数器被设置为1；
给对象发送一条retain消息,可以使引用计数器值+1；
给对象发送一条release消息,可以使引用计数器值-1；
当一个对象的引用计数器值为0时,那么它将被销毁,其占用的内存被系统回收,系统也会自动向对象发送一条dealloc消息。一般会重写dealloc方法,在这里释放相关资源。一定不要直接调用dealloc方法；
可以给对象发送retainCount消息获得当前的引用计数器值；

一些概念：

 1>僵尸对象：所占用内存已经被回收的对象，僵尸对象不能再使用

 2>野指针：指向僵尸对象（不可用内存）的指针，给野指针发送消息会报错（EXC_BAD_ACCESS）

 3>空指针：没有指向任何东西的指针（存储的东西是nil、NULL、0），给空指针发送消息不会报错

#import 
    
    
     
     
#import "Person.h"

int main()
{
    // 1
    Person *p = [[Person alloc] init];   
    NSUInteger c = [p retainCount];   
    NSLog(@"计数器：%ld", c); 
    // 2 retain方法返回的是对象本身
    [p retain];   
    // 1
    [p release];
    
    // 0 野指针：指向僵尸对象（不可用内存）的指针
    [p release];  
    [p retain];
    
    // -[Person setAge:]: message sent to deallocated instance 0x100109a10
    // 给已经释放的对象发送了一条-setAge:消息：
    p.age = 10;
    //[p setAge:10];
    
    // 指针p变成空指针
    //p = nil;
    
    // EXC_BAD_ACCESS : 访问了一块坏的内存（已经被回收、已经不可用的内存
    // 野指针错误
    // OC不存在空指针错误，给空指针发送消息，不报错
    [p release];
    [p release];
    [p release];
    [p release];  
    [nil release];  
    return 0;
}

    
    

3.内存管理原则

1.谁创建，谁释放(“谁污染，谁治理”)。如果你通过alloc、new或(mutable)copy来创建一个对象，那么你必须调用release或autorelease。换句话说，不是你创建的，就不用你去释放

2.一般来说,除了alloc、new或copy之外的方法创建的对象都被声明了autorelease

3.谁retain，谁release。只要你调用了retain，无论这个对象是如何生成的，你都要调用release

多个对象之间内存管理：

 1.想使用（占用）某个对象，就应该让对象的计数器+1（让对象做一次retain操作）

 2.不想再使用（占用）某个对象，就应该让对象的计数器-1（让对象做一次release）

 3.谁retain，谁release

 4.谁alloc，谁release

#import 
    
    
     
     
#import "Book.h"

@interface Person : NSObject
{
    Book *_book; 
}

- (void)setBook:(Book *)book;
- (Book *)book;

@end
@implementation Person
- (void)setBook:(Book *)book
{
// 使用了book，所以retain
    _book = [book retain];
}

- (Book *)book
{
    return _book;
}

- (void)dealloc
{
 // 不适用book，release
    [_book release];
    NSLog(@"Person对象被回收");
    [super dealloc];
}
@end
    
    

set方法的内存管理

set方法的实现

- (void)setDog:(dog *)dog
{
    if(_dog!=dog)
  {
      [_dog release];
      _dog=[dog retain];
      [_age retain];
   }
}

dealloc的实现

- (void)dealloc
{
  [_dog release];
  [super dealloc];
}

4.@property参数的使用

控制set方法的内存管理

1.retain： release旧值,retain新值(用于OC对象);

2.assign:直接赋值,不作任何类存管理(用于基本数据类型);

3.copy:release旧值,copy新值(一般用于NSString *).

控制是否只读属性

readwtite:可读可写,生成get和set方法;

readonly:只读,只生成get方法.

多线程管理

atomic:性能低(默认);

nonatomic:性能高()

控制set和get方法名

setter:

getter

//OC对象
@property(nonatomic,retain)Book * book;
//基本数据类型
@property(nonatomic,assign)int age;
//只读的基本数据类型
@property(nonatomic,readwrite,assign)int height;

5.@class的使用

通常引用一个类有两种办法：

一种是通过#import方式引入；

#import 
    
    
     
     
#import "Book.h"

@interface Person : NSObject
{
    Book *_book;
}

- (void)setBook:(Book *)book;
- (Book *)book;

@end
    
    

一种是通过 @class 引入

#import 
    
    
     
     
@class Book

@interface Person : NSObject
{
    Book *_book;
}
- (void)setBook:(Book *)book;
- (Book *)book;
@end
    
    

两种方式的区别:

1、#import方式会包含被引用类的所有信息，包括被引用类的变量和方法；

2、@class方式只是告诉编译器在A.h文件中B *b只是类的声明，具体这个类里有什么信息，这里不需要知道，等实现文件中真正要用到时，才会真正去查看B类中信息；

3、使用@class方式由于只需要知道被引用类（B类）的名称就可以了，而在实现类由于要用到被引用类中的实体变量和方法，所以在.m文件中需要使用#import来包含被引用类的头文件；
4、如果有上百个头文件都#import了同一个文件，或者这些文件依次被#improt,那么一旦最开始的头文件稍有改动，后面引用到这个文件的所有类都需要重新编译一遍，这样的效率也是可想而知的，而相对来 讲，使用@class方式就不会出现这种问题了。

5.对于循环依赖关系来说，比方A类引用B类，同时B类也引用A类，B类的代码：

#import "A.h"
@interface B:NSObject
{A *a;  }
@end

当程序运行时，编译会报错。当使用@class在两个类相互声明，就不会出现编译报错。
由上可知，@class是放在.h中的，只是在引用一个类，将这个被引用类作为一个类型，在.m实现文件中，如果需要引用到被引用类的实体变量或者方法时，还需要使用#import方式引入被引用类。

6.autorelease pool

自动释放池是OC里面的一种内存自动回收机制,一般可以将一些临时变量添加到自动释放池中,统一回收释放
当自动释放池销毁时,池里面的所有对象都会调用一次release方法.

OC对象只需要发送一条autorelease消息,就会把这个对象添加到最近的自动释放池中(栈顶的释放池)
autorelease实际上只是把对release的调用延迟了，对于每一次autorelease，系统只是把该对象放入了当前的autorelease pool中，当该pool被释放时，该pool中的所有对象会被调用Release;

1.autorelease的基本用法

1> 会将对象放到一个自动释放池中
 2> 当自动释放池被销毁时，会对池子里面的所有对象做一次release操作
 3> 会返回对象本身
 4> 调用完autorelease方法后，对象的计数器不变

@autoreleasepool
        {
            // 1
            Person *p2 = [[[Person alloc] init] autorelease];
            p2.age = 10;
                    
        }

2.autorelease的好处

 1> 不用再关心对象释放的时间
 2> 不用再关心什么时候调用release

    @autoreleasepool
    {// { 开始代表创建了释放池
        
        // autorelease方法会返回对象本身
        // 调用完autorelease方法后，对象的计数器不变
        // autorelease会将对象放到一个自动释放池中
        // 当自动释放池被销毁时，会对池子里面的所有对象做一次release操作
        Person *p = [[[Person alloc] init] autorelease];
        
        p.age = 10;
   
        @autoreleasepool
        {
            // 1
            Person *p2 = [[[Person alloc] init] autorelease];
            p2.age = 10;             
        }      
        
        Person *p3 = [[[Person alloc] init] autorelease];
                
    } // } 结束代表销毁释放池

3.autorelease的使用注意

 1> 占用内存较大的对象不要随便使用autorelease
 2> 占用内存较小的对象使用autorelease，没有太大影响

4.错误写法

1> alloc之后调用了autorelease，又调用release

 @autoreleasepool
 {
    // 1
    Person *p = [[[Person alloc] init] autorelease];
 
    // 0
    [p release];
 }

 2> 连续调用多次autorelease

 @autoreleasepool
 {
    Person *p = [[[[Person alloc] init] autorelease] autorelease];
 }