黑马程序员-OC-内存管理

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

 移动设备的内存一般是比较小的，所以每个应用程序占用的内存都应该是有一定限制的。从而合理的应用有限的内存是十分必要的，在一些对象和变量不使用后就应该及时的释放，为其他对象和变量提供内存空间。

引用计数器的基本操作:

引用计数器，是用来记录每个OC对象被引用的次数，即现在使用OC对象的次数。每个OC对象都有自己的一个引用计数器，它随着对象被创建而生成，默认计数器值为1，当又有对象调用时+1，当不再利用时释放-1，如果对象计数器为0时，则对象销毁。

每个OC对象内部都有，专门的4个字节来储存引用计数器。

引用计数器是判断对象是否存在的唯一依据。

操作方式：

 1> retain ：计数器+1，会返回对象本身

 2> release ：计数器-1，没有返回值

 3> retainCount ：获取当前的计数器

以上3种方式可以操作引用计数器

对象的销毁：

当引用计数器的值变为0时，对象会被销毁，对象所占的内存会被系统回收。

对象销毁时，系统会自动像对象发送一条dealloc消息，这就像是对象发出来一条“遗言”。所以一般会重写dealloc方法，在里面释放一些有关的对象。

<span style="font-size:14px;">#import "Person.h"
@implementation Person
// 当一个Person对象被回收的时候，就会自动调用这个方法
- (void)dealloc
{
    NSLog(@"Person对象被回收");
    
    // super的dealloc一定要调用，而且放在最后面
    [super dealloc];
}
@end</span>

在重写dealloc方法是必须如上调用[super dealloc]，并且将其放在代码块的最后调用。

一旦程序被回收，就可能出现野指针错误

<span style="font-size:14px;">#import <Foundation/Foundation.h>
#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;
}</span>

 1> 僵尸对象 ：所占用内存已经被回收的对象，僵尸对象不能再使用。注意对象成为僵尸对象后，不能”死而复生“。
 2> 野指针 ：指向僵尸对象（不可用内存）的指针，给野指针发送消息会报错（EXC_BAD_ACCESS）

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

多个对象之间的内存管理：

main.m

<span style="font-size:14px;">#import <Foundation/Foundation.h>
#import "Person.h"
#import "Book.h"

int main()
{
    // b-1
    Book *b = [[Book alloc] init];
    // p-1
    Person *p1 = [[Person alloc] init];
    
    //p1想占用b这本书
    // b-2
    [p1 setBook:b];
    
    // p-0
    // b-1
    [p1 release];
    p1 = nil;
    
    // b-0
    [b release];
    b = nil;
    return 0;
}</span>

要想实现以上这样对OC对象的合理释放，需要要一下代码配合：

Person.m

<span style="font-size:14px;">#import "Person.h"

@implementation Person
- (void)setBook:(Book *)book
{
    _book = [book retain];
}

- (Book *)book
{
    return _book;
}

- (void)dealloc
{
    [_book release];
    NSLog(@"Person对象被回收");
    [super dealloc];
}
@end</span>

 1.你想使用（占用）某个对象，就应该让对象的计数器+1（让对象做一次retain操作）
 2.你不想再使用（占用）某个对象，就应该让对象的计数器-1（让对象做一次release）
 3.谁retain，谁release
 4.谁alloc，谁release

set方法代码规范：

 内存管理代码规范：
 1.只要调用了alloc，必须有release（autorelease）
   对象不是通过alloc产生的，就不需要release
 
 2.set方法的代码规范
 1> 基本数据类型：直接复制

<span style="font-size:14px;"> - (void)setAge:(int)age
 { 
    _age = age;
 }</span>

 
 2> OC对象类型

<span style="font-size:14px;"> - (void)setCar:(Car *)car
 {
    // 1.先判断是不是新传进来对象
    if ( car != _car )
    {
        // 2.对旧对象做一次release
        [_car release];
 
        // 3.对新对象做一次retain
        _car = [car retain];
    }
 }</span>

 
 3.dealloc方法的代码规范
 1> 一定要[super dealloc]，而且放到最后面
 2> 对self（当前）所拥有的其他对象做一次release

<span style="font-size:14px;"> - (void)dealloc
 {
    [_car release];
    [super dealloc];
 }</span>

@property参数

 1.set方法内存管理相关的参数
 * retain : release旧值，retain新值（适用于OC对象类型）
 * assign : 直接赋值（默认，适用于非OC对象类型）
 * copy   : release旧值，copy新值
 
 2.是否要生成set方法
 * readwrite : 同时生成setter和getter的声明、实现(默认)
 * readonly  : 只会生成getter的声明、实现
 
 3.多线程管理
 * nonatomic : 性能高 (一般就用这个)
 * atomic    : 性能低（默认）
 
 4.setter和getter方法的名称
 * setter : 决定了set方法的名称，一定要有个冒号 :
 * getter : 决定了get方法的名称(一般用在BOOL类型)

代码示例：

<span style="font-size:14px;">#import <Foundation/Foundation.h>

@interface Person : NSObject

// 返回BOOL类型的方法名一般以is开头
@property (getter = isRich) BOOL rich;

//   
@property (nonatomic, assign, readwrite) int weight;
// setWeight:
// weight

// 
@property (readwrite, assign) int height;

@property (nonatomic, assign) int age;

@property (retain) NSString *name;
@end
</span>

循环引用：

<span style="font-size:14px;">#import <Foundation/Foundation.h>
#import "Card.h"
#import "Person.h"

int main()
{
    // p - 1
    Person *p = [[Person alloc] init];
    // c - 1
    Card *c = [[Card alloc] init];
    
    // c - 2
    p.card = c;
    
    // p - 1
    c.person = p;
    
    // c - 1
    [c release];
    
    // p - 0  c - 0
    [p release];
    return 0;
}</span>

以上情况两个对象相互引用，如果使用强指针会致使其中一个对象的内存无法释放。

所以两端循环引用使用 一端用retain，另 一端用assign的方法解决这类问题。一强一弱，当强指针释放时，弱指针跟着就释放完成。

 1.@class的作用：仅仅告诉编译器，某个名称是一个类
 @class Person; // 仅仅告诉编译器，Person是一个类
 
 2.开发中引用一个类的规范
 1> 在.h文件中用@class来声明类
 2> 在.m文件中用#import来包含类的所有东西

Autorelease：

1.autorelease的基本用法
 1> 会将对象放到一个自动释放池中
 2> 当自动释放池被销毁时，会对池子里面的所有对象做一次release操作
 3> 会返回对象本身
 4> 调用完autorelease方法后，对象的计数器不变
 
 2.autorelease的好处
 1> 不用再关心对象释放的时间
 2> 不用再关心什么时候调用release
 
 3.autorelease的使用注意
 1> 占用内存较大的对象不要随便使用autorelease
 2> 占用内存较小的对象使用autorelease，没有太大影响
 
 
 4.错误写法
 1> alloc之后调用了autorelease，又调用release
 

<span style="font-size:14px;">@autoreleasepool
 {
    // 1
    Person *p = [[[Person alloc] init] autorelease];
 
    // 0
    [p release];
 }</span>

 
 2> 连续调用多次autorelease

<span style="font-size:14px;"> @autoreleasepool
 {
    Person *p = [[[[Person alloc] init] autorelease] autorelease];
 }
 </span>

 3.自动释放池
 1> 在iOS程序运行过程中，会创建无数个池子。这些池子都是以栈结构存在（先进后出）
 2> 当一个对象调用autorelease方法时，会将这个对象放到栈顶的释放池
 
 
 4.自动释放池的创建方式
 1> iOS 5.0前使用
 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 
 [pool release]; // [pool drain];
 
 
 2> iOS 5.0 开始使用
 @autoreleasepool
 {
    
 }

代码示例：

<span style="font-size:14px;">int main()
{
    @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];
        
    } // } 结束代表销毁释放池    
    renturn 0;
}</span>

ARC的使用

 ARC的判断准则：只要没有强指针指向对象，就会释放对象
 
ARC特点
 1> 不允许调用release、retain、retainCount
 2> 允许重写dealloc，但是不允许调用[super dealloc]
 3> @property的参数
  * strong ：成员变量是强指针（适用于OC对象类型）
  * weak ：成员变量是弱指针（适用于OC对象类型）
  * assign : 适用于非OC对象类型
 4> 以前的retain改为用strong
 
 指针分2种：
 1> 强指针：默认情况下，所有的指针都是强指针 __strong
 2> 弱指针：__weak

在arc中的循环引用：

 当两端循环引用的时候，解决方案：
 1> ARC
 1端用strong，另1端用weak
 
 2> 非ARC
 1端用retain，另1端用assign

代码示例：

Dog.h

<span style="font-size:14px;">#import <Foundation/Foundation.h>

@class Person;

@interface Dog : NSObject

@property (nonatomic, weak) Person *person;

@end
</span>

Person.h

<span style="font-size:14px;">#import <Foundation/Foundation.h>

@class Dog;

@interface Person : NSObject

@property (nonatomic, strong) Dog *dog;

@end
</span>