黑马程序员-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>