OC开发系列-内存管理

时间:2022-10-08 15:03:15

概述

移动设备的内存极其有限,每个app所有占用的内存是有限的。当app所占用的内存比较多时,系统会发出内存警告,这时得回收一些不需要再使用的内存空间。

任何集成了NSObject的对象都需要手动进行内存管理。因为OC对象存放于堆里面。

引用计数器

  • 每一个OC对象都有内部有自己的引用计数器。该计数器占用4个字节。从字面可以理解为"多少人在使用这个对象"。
  • 当对象的引用计数器为0时。该对象会才会被释放。
  • 一个对象通过alloc、 copy 、new创建一个对象,该对象默认的引用计数器为1。

引用计数器的操作

* 给对象发送一条retain消息,对象的引用计数器+1
* 给对象发送一条release消息,对象的引用计数器-1
* 给对象发送一条retainCount消息,对获得当前对象的引用计数器值

dealloc方法

当一个对象的引用计数器值为0时,这个对象即将被销毁,器占用的内存被系统回收。对象即将被销毁前系统会自动给改对象发送一条dealloc消息。

通常重写对象的dealloc方法释放相关的资源。

* 一旦重写了dealloc方法,就必须调用[super dealloc],并且放在最后面

* dealloc不能直接调用

* 一旦对象被回收,它占用的内存就不再可用被称之为僵尸对象。指向僵尸对象的指针被称为野指针。给僵尸对象发消息会造坏访问报错。

OC开发系列-内存管理

多对象的内存管理

多个对象进行内存管理,并且对象之间是有联系的,那么管理就会变得比较复杂。

比如在内存中有一个聊天室对象,多个Person对象共同使用者聊天室对象。

OC开发系列-内存管理

对上面的实例我们如果想做好聊天室对象跟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执行完毕内存的情况。

OC开发系列-内存管理

为什么执行p跟c的release方法,对象没有销毁。因为在给人对象赋值car对象的时候通过set方法会对car对象引用计数器+1,同理对car对象赋值人对象,人对象引用计数器也会+1。

OC开发系列-内存管理

分别执行两个对象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的混编

OC开发系列-内存管理

* 在ARC项目中执行某个文件使用MRC -fno-objc-arc

* 在MRC项目中执行某个文件使用ARC -fobjc-arc

使用Xcode将一个MRC工程转化成ARC项目

OC开发系列-内存管理