概述
移动设备的内存极其有限,每个app所有占用的内存是有限的。当app所占用的内存比较多时,系统会发出内存警告,这时得回收一些不需要再使用的内存空间。
任何集成了NSObject的对象都需要手动进行内存管理。因为OC对象存放于堆里面。
引用计数器
- 每一个OC对象都有内部有自己的引用计数器。该计数器占用4个字节。从字面可以理解为"多少人在使用这个对象"。
- 当对象的引用计数器为0时。该对象会才会被释放。
- 一个对象通过alloc、 copy 、new创建一个对象,该对象默认的引用计数器为1。
引用计数器的操作
* 给对象发送一条retain消息,对象的引用计数器+1
* 给对象发送一条release消息,对象的引用计数器-1
* 给对象发送一条retainCount消息,对获得当前对象的引用计数器值
dealloc方法
当一个对象的引用计数器值为0时,这个对象即将被销毁,器占用的内存被系统回收。对象即将被销毁前系统会自动给改对象发送一条dealloc
消息。
通常重写对象的dealloc
方法释放相关的资源。
* 一旦重写了dealloc方法,就必须调用[super dealloc],并且放在最后面
* dealloc不能直接调用
* 一旦对象被回收,它占用的内存就不再可用被称之为僵尸对象。指向僵尸对象的指针被称为野指针。给僵尸对象发消息会造坏访问报错。
多对象的内存管理
多个对象进行内存管理,并且对象之间是有联系的,那么管理就会变得比较复杂。
比如在内存中有一个聊天室对象,多个Person对象共同使用者聊天室对象。
对上面的实例我们如果想做好聊天室对象跟Person对象的内存管理。需要做到下面两点
* 只要有人在使用聊天室对象聊天室对象就不能销毁
* 没有人使用聊天室对象聊天室对象需要销毁
当有Person对象使用聊天室就需要对聊天室对象的引用计数器+1。且当Person对象销毁之前需要对使用的房间对象引用计数器-1,这样就可以保证以上两点。
因此可以这样定义一个Person类
#import <Foundation/Foundation.h>
#import "ChatRoom.h"
@interface Person : NSObject
{
ChatRoom *_cRoom;
}
- (void)setCRoom:(ChatRoom *)cRoom;
- (ChatRoom *)cRoom;
@end
#import "Person.h"
@implementation Person
- (void)setCRoom:(ChatRoom *)cRoom
{
if (_cRoom != cRoom) {
// 1.先对以前的对象计数器-1
[_cRoom release];
// 2.调用对象的retain返回对象本身
_cRoom = [_cRoom retain];
}
}
- (ChatRoom *)cRoom
{
return _cRoom;
}
- (void)dealloc
{
// 在Person对象即将销毁先对内部的聊天室对象计数器-1
[_cRoom release];
[super dealloc];
}
@end
Property修饰符
assign
默认Proerty修饰符为assig。比如当为Person声明一个成员属性@property int age;
编译器自动转换成@property(assign) int age;
。
retain
Proerty修饰符为retain在生成的set方法会自动生成set方法的内存管理代码
@property (retain) ChatRoom *cRoom;
retain修饰生成的set方法:
- (void)setCRoom:(ChatRoom *)cRoom
{
if (_cRoom != cRoom) {
// 1.先对以前的对象计数器-1
[_cRoom release];
// 2. 调用对象的retain返回对象本身
_cRoom = [_cRoom retain];
}
}
nonatomic与nonnull
nonatomic是保证set方法是线程安全的,nonnull则相反。iOS开发一般使用nonatomic性能高。
@class
@class主要用于简单的引用一个类。@class与#import有着本质的区别,#import是预处理指令在程序预处理时期对#import的文件进行拷贝,而@class只是告诉编译器@class后面引用的是一个类。
import有一个特点,只要引用的文件发生的变化,那么import就会重新拷贝一次。比如现在有三个类Person、 Car、 Wheel。Person.h文件import Car.h,Car.h文件import Wheel.h。一旦wheels Wheel.h发生变化,Car.h需要重新拷贝Wheel.h并且Person.h也重新拷贝Car.h。
@class具体使用
* 在.h文件中使用@class引用一个类
* 在.m文件中使用#import包含这个类的.h文件
@class其他使用场景
- 对于循环依赖关系来说,比方A类引用B类,同时B类也引用A类 这种嵌套包含的代码编译报错
- 当使用@class在两个类相互声明,就不会出现编译报错。
retain的循环引用
现在有两个类Person与Car。Person中有个成员属性car,Car中有个成员属性person。
Person类
#import <Foundation/Foundation.h>
@class Car;
@interface Person : NSObject
@property (retain) Car *car;
@end
#import "Person.h"
@implementation Person
- (void)dealloc
{
[_car release];
[super dealloc];
NSLog(@"%s", __func__);
}
@end
Car类
#import <Foundation/Foundation.h>
@class Person;
@interface Car : NSObject
@property (retain) Person *per;
@end
#import "Car.h"
@implementation Car
- (void)dealloc
{
[_per release];
[super dealloc];
NSLog(@"%s", __func__);
}
@end
main.m
#import <Foundation/Foundation.h>
#import "Person.h"
#import "Car.h"
int main(int argc, const char * argv[]) {
@autoreleasepool {
Person *p = [[Person alloc] init];
Car *c = [[Car alloc] init];
// 人赋值一辆车对象
p.car = c;
// 车赋值人对象
c.per = p;
[p release];
[c release];
}
return 0;
}
main.m代码执行完控制台并没有Person对象与Car对象dealloc方法的打印。因此内存两个对象并未销毁存在内存泄漏。下面画图展现main.m执行完毕内存的情况。
为什么执行p跟c的release方法,对象没有销毁。因为在给人对象赋值car对象的时候通过set方法会对car对象引用计数器+1,同理对car对象赋值人对象,人对象引用计数器也会+1。
分别执行两个对象release只是让对象应用计数器-1,因此两个对象都没有销毁。
那么我们可以尝试让其中一个类Property修饰符修改为assign。注意:修改为assign修饰一方dealloc千万不要在dealloc对对象属性进行release。否则会造成内存坏访问
此时的Person类
#import <Foundation/Foundation.h>
@class Car;
@interface Person : NSObject
// 改为assign修饰
@property (assign) Car *car;
@end
#import "Person.h"
@implementation Person
- (void)dealloc
{
// [_car release]; 此时Propery修饰符为assign不需要对car进行release
[super dealloc];
NSLog(@"%s", __func__);
}
@end
autorelease
通过上面讲解,OC多对象的内存管理主要有以下几点:
* 1.在外界通过alloc、copy、new关键字创建的对象需要释放的时候发送release消息
* 2.在set方法中对赋值的对象引用计数器+1,可以使用retain关键字自动生成set方法内存管理代码
* 3.在一个对象即将要销毁前在dealloc方法中对内部引用的对象进行release。
这里就会发现,我们需要时时刻刻关注对象什么时候需要销毁时发送release消息。接下来就可以通过autorelease的机制来解决手动编写大量的对象的release代码。不需要一直再关注对象什么时候需要release。只要可以访问到对象的作用域都可以使用对象。
autorelease是一种支持引用计数器的内存管理方式,只要给对象发送一条autorelease消息会将对象放到自动释放池中。当自动释放池销毁,会对池子中的所有对象发送一条release消息。autorelease操作对象的引用计数器。当一个对象发送release消息返回时对象的本身。
#import <Foundation/Foundation.h>
#import "Person.h"
int main(int argc, const char * argv[]) {
@autoreleasepool {
Person *p = [[Person alloc] init];
// 将对象p添加到autorelease释放池
p = [p autorelease];
// [p release]; 这里不需要在写release 否则坏访问
}// 自动释放池销毁会给对象中所有的对象发送一条release消息
return 0;
}
在iOS5.0之前autorelease的写法
int main(int argc, const char * argv[]) {
// 创建一个自动释放池
NSAutoreleasePool *pool =[[NSAutoreleasePool alloc] init];
Person *p = [[Person alloc] init];
// 将对象p添加到autorelease释放池
p = [p autorelease];
[pool drain]; // 自动释放池销毁会给对象中所有的对象发送一条release消息
return 0;
}
MRC类工厂方法的编写
我们在初始化一个对象将它添加进自动释放池中
@autoreleasepool{
// 创建一个对象
Person *p = [[[Person alloc] init] autorelease];
}
可见每次创建一个Person对象都需要写很长的代码,于是我们可以封装内部细节提供一个类工厂方法
/**快速创建一个Person实例*/
+ (instancetype)person;
+ (instancetype)person
{
return [[[self alloc] init] autorelease];
}
外界调用类工厂对象初始化对象
int main(int argc, const char * argv[]) {
@autoreleasepool{
// 创建一个对象
Person *p = [[[Person alloc] init] autorelease];
// 通过类工厂方法 创建的对象默认添加进自动释放池当中
Person *p1 = [Person person];
}
return 0;
}
我们想让Person在初始化后就有一个默认的名字。我们可以提供自定义构造方法。
#import <Foundation/Foundation.h>
@interface Person : NSObject
@property(nonatomic, copy) NSString *name;
/**快速创建一个Person实例*/
+ (instancetype)person;
/**自定义构造方法*/
-(instancetype)initWithName:(NSString *)name;
+(instancetype)personWithName:(NSString *)name;
@end
#import "Person.h"
@implementation Person
/**自定义构造方法*/
-(instancetype)initWithName:(NSString *)name
{
if(self = [super init]){
self.name = name;
}
return self;
}
+ (instancetype)person
{
return [[[self alloc] init] autorelease];
}
+(instancetype)personWithName:(NSString *)name
{
// 类方法中将对象添加进自动释放池中
return [[self initWithName:name] autorelease];
}
@end
上面的代码会发现在MRC类方法中生成的对象默认内部将其添加自动释放池当中,其实这也是苹果的规范。苹果Foundation框架中通过类方法创建的对象都是autorelease。
ARC的内存管理
ARC是编译器的特性,而不是运行时特性,跟其他语言的垃圾回收有着本质的区别。ARC原理就是在编译阶段为我们在必要的时候添加release这些代码。
ARC的判断原则
* 只要还有一个强指针指向对象,对象就会保持在内存中
ARC与MRC的混编
* 在ARC项目中执行某个文件使用MRC -fno-objc-arc
* 在MRC项目中执行某个文件使用ARC -fobjc-arc
使用Xcode将一个MRC工程转化成ARC项目