昨天学习了OC的内存管理机制，今天想总结一下，所以接下来我要在这里bibi一下：OC的内存管理。
首先我要说的是，内存管理的作用范围。
内存管理的作用范围：
任何继承了NSObject的对象，对其他基本数据类型无效，例如：int ，float，BOOL等。
每个OC对象都有自己的引用计数器，用来表示对象被引用的次数。
每个OC对象内部都有4个字节的存储空间用来存储引用计数器。
在使用alloc、new或者copy创建新对象的时候，新对象的引用计数器默认值为1
当一个对象的引用计数器的值为0时，对象占用的内存就会被系统回收。
下面说说，引用计数器的用法
1> retain：计数器+1，会返回对象本身（id）。
2> release：计数器-1，没有返回值（void）。
3> retainCount：获取对象当前的引用计数器的值。
对象销毁
当一个对象的引用计数器的值为0时，该对象将被销毁，其占用的内存被系统回收。当一个对象被回收时，调用dealloc方法。一般情况下会重写dealloc，来释放相关资源。重写dealloc方法时，有一定要在最后面调用[super dealloc]。对象被回收之后，其占用的内存不可再用。
如下代码，简单说一下内存管理操作
int main()
{
Person *p = [[Person alloc] init]; // 创建对象，此时引用计数器值为：1 [p retain]; // 对对象p做一次retain操作 引用计数器+1，此时为：2 [p release]; // 对对象p做一次release操作 引用计数器-1，此时为：1 [p release]; // 对对象p做一次release操作 引用计数器-1，此时为：0 // p.name = @"jack"; // 这时p为野指针，p指向的对象为僵尸对象
p = nil; // 将p指针的值清空 return ;
}
OC中有一个名词叫僵尸对象，下面说说，什么是僵尸对象？
僵尸对象：所占用内存已经被回收的对象，僵尸对象不能使用。
野指针：指向僵尸对象的指针，给野指针发送消息会报错(EXC_BAD_ACCESS)。
空指针：没有指向任何东西的指针(存储的内容是nil、NULL、0)，给空指针发送消息不会报错。
之前说的是单个对象，那么多个对象之前的内存管理是怎么样子的呢？
多对象之间的内存管理
使用某个对象，则对该对象做一次retain操作。结束使用时，对该对象做一次release操作。
原则是：谁retain，谁release；谁alloc，谁release。
示例代码如下：
@class Dog; // 因为Dog类还没有声明，要先告诉编译器Dog是一个类
@interface Person : NSObject
@property(nonatomic,assign) NSString *name;
@property(nonatomic,assign) int age;
// Person对象包含一个Dog对象，当调用Dog对象时，要对dog对象进行一次retain操作
@property(nonatomic,retain) Dog *dog;
@end
@implementation Person
- (void)setDog:(Dog *)dog
{ // 判断dog是否为新dog
if (dog != _dog) {
// 是新dog则对老dog进行一次release操作
[_dog release];
// 对新dog进行一次retain操作
_dog = [dog retain];
}
}
// dealloc重写，用来release Person的Dog
- (void)dealloc
{
// 谁retain谁release，当_dog的值为nil、NULL、0时 对它发送release消息,没有任何意义
[_dog release];
// 重写dealloc要在最后面调用父类的dealloc方法[super dealloc]
[super dealloc];
}
@end
@property参数
set方法内存管理相关参数
retain：release旧值，retain新值(适用于OC对象类型)。
assign：直接赋值(默认、适用于非OC对象类型)。
copy：release旧值，copy新值(一般用于NSString *)。
set、get方法的生成
readwrite：同时生成set方法和get方法的声明与实现(默认)。
readonly：只生成get方法的声明与实现。
多线程管理
nonatomic：性能高 (一般使用这个值)。
atomic ：性能低 (默认值)。
set方法和get方法的名称
setter：决定set方法的名称，必须有冒号：
getter：决定get方法的名称 (一般用在BOOL类型 isXX)。
对象循环引用中的内存管理
当两个对象互相引用时，在一个对象的@property中使用retain，另一个对象的@property中使用assign。
@class Dog; // 因为Dog类还没有声明，要先告诉编译器Dog是一个类
@interface Person : NSObject
@property(assign,nonatomic) NSString *name;
@property(assign,nonatomic) int age;
// Person对象包含一个Dog对象，当调用Dog对象时，要对dog对象进行一次retain操作
@property(retain,nonatomic) Dog *dog;
@end
@implementation Person
- (void)setDog:(Dog *)dog
{ // 判断dog是否为新dog
if (dog != _dog) {
// 是新dog则对老dog进行一次release操作
[_dog release];
// 对新dog进行一次retain操作
_dog = [dog retain];
}
}
// dealloc重写，用来release Person的Dog
- (void)dealloc
{
// 谁retain谁release，当_dog的值为nil、NULL、0时 对它发送release消息,没有任何意义
[_dog release];
// 重写dealloc要在最后面调用父类的dealloc方法[super dealloc]
[super dealloc];
}
@end
@interface Dog : NSObject
// Person和Dog互相调用，Person中用retain，Dog中用assign
@property(assign,nonatomic) Person *person;
@property(assign,nonatomic) NSString *name;
@end
@implementation Dog
// Dog没有对person进行retain操作，不用对它进行release
@end
int main()
{
// 对象的循环调用
Person *p1 = [[Person alloc] init]; // 引用计数器值为：1
Dog *d1 = [[Dog alloc] init]; // 引用计数器值为：1
Dog *d2 = [[Dog alloc] init]; // 引用计数器值为：1 p1.dog = d1; // d1引用计数器值为：2
d1.person = p1; // p1引用计数器值为：2
// p1的dog换成d2，在p1的set方法里对d1进行一次release，对d2进行一次retain。
p1.dog = d2; // d1引用计数器值为：1 d2引用计数器值为：2
[d1 release]; // d1引用计数器值为：0
[d2 release]; // d2引用计数器值为：1
[p1 release]; // p1引用计数器值为：0，d2引用计数器值为：0
return ;
}
@class的使用
通常引用一个类有两种办法：
一种是通过#import方式引入；
#import <Foundation/Foundation.h>
#import "Book.h" @interface Person : NSObject
{
Book *_book;
} - (void)setBook:(Book *)book;
- (Book *)book; @end
一种是通过@class引入
1、#import方式会包含被引用类的所有信息，包括被引用类的变量和方法；
2、@class方式只是告诉编译器在A.h文件中B *b只是类的声明，具体这个类里有什么信息，这里不需要知道，等实现文件中真正要用到时，才会真正去查看B类中信息；
3、使用@class方式由于只需要知道被引用类（B类）的名称就可以了，而在实现类由于要用到被引用类中的实体变量和方法，所以在.m文件中需要使用#import来包含被引用类的头文件；
4、如果有上百个头文件都#import了同一个文件，或者这些文件依次被#improt,那么一旦最开始的头文件稍有改动，后面引用到这个文件的所有类都需要重新编译一遍，这样的效率也是可想而知的，而相对来 讲，使用@class方式就不会出现这种问题了。
5.对于循环依赖关系来说，比方A类引用B类，同时B类也引用A类，B类的代码：
由上可知，@class是放在.h中的，只是在引用一个类，将这个被引用类作为一个类型，在.m实现文件中，如果需要引用到被引用类的实体变量或者方法时，还需要使用#import方式引入被引用类。
下来说一说，autorelease方法
1> 会将对象放到一个自动释放池中。
2> 当自动释放池被销毁时，会对池内所有对象做一次release操作。
3> autorelease方法会返回对象本身。
4> 调用autorelease方法之后，对象的计数器不变。
自动释放池
在程序运行过程中，可以创建多个自动释放池。自动释放池以栈的形式存在内存中(先进后出)。
当对象调用autorelease方法时，会将该对象放到栈顶的释放池。
创建自动释放池
int main()
{
// 创建自动释放池
@autoreleasepool{
// 创建对象，并调用autorelease方法
Person *p = [[[Person alloc] init] autorelease];
} // 自动释放池销毁，对象销毁 return ;
}
一般当对象占用内存较大时，不要使用autorelease。调用autorelease之后，不用再使用release。
一般来说，除了alloc、new或copy之外的方法创建的对象都被声明了autorelease。
开发中可以提供一些类方法来快速创建已经autorelease的对象。
例如：
+ (id)person
{
// 创建对象时，不直接使用类名，建议使用self
return [[[self alloc] init] autorelease]
}
ARC(Automatic Reference Counting)
在ARC模式下把指针分为两种
强指针：默认情况下，所有指针都是强指针__strong。
弱指针：__weak 。
@interface Person : NSObject
@property(strong,nonatomic) Dog *dog;
@end @implementation Person
// 重写dealloc
-(void)dealloc
{
NSLog(@"Person被杀死了");
// [super dealloc];不允许调用
}
@end @interface Dog : NSObject
@property(weak,nonatomic) Person *person;
@end @implementation Dog
- (void)dealloc
{
NSLog(@"Dog被杀死了");
}
@end int main()
{
// ARC模式下的循环调用
Person *p = [[Person alloc] init];
Dog *d = [[Dog alloc] init]; p.dog = d;
d.person = p; return ;
}// 程序结束，所有对象被销毁
ARC特点
1> 不允许调用release、retain、retainCount。
2> 允许重写dealloc，但是不允许调用[super dealloc]。
3> @property参数
strong：成员变量是强指针(适用于OC对象类型)。
weak：成员变量是弱指针(适用于OC对象类型)。
assign：适用于非OC对象类型。
4> 用strong替代retain。
ARC中的循环引用：strong替代retain，weak替代assign 。
好了，对于OC内存管理的初步总结先写到这里，因为是初次学习，有错误请指正，感谢！