iOS开发系列—Objective-C之内存管理

概述

我们知道在程序运行过程中要创建大量的对象，和其他高级语言类似，在ObjC中对象时存储在堆中的，系统并不会自动释放堆中的内存（注意基本类型是由系统自己管理的，放在栈上）。如果一个对象创建并使用后没有得到及时释放那么就会占用大量内存。其他高级语言如C#、Java都是通过垃圾回收来（GC）解决这个问题的，但在OjbC中并没有类似的垃圾回收机制，因此它的内存管理就需要由开发人员手动维护。今天将着重介绍ObjC内存管理：

  1. 引用计数器
  2. 属性参数
  3. 自动释放池

引用计数器

在Xcode4.2及之后的版本中由于引入了ARC（Automatic Reference Counting）机制,程序编译时Xcode可以自动给你的代码添加内存释放代码，如果编写手动释放代码Xcode会报错，因此在今天的内容中如果你使用的是Xcode4.2之后的版本（相信现在大部分朋友用的版本都比这个要高），必须手动关闭ARC，这样才有助于你理解ObjC的内存回收机制。

ObjC中的内存管理机制跟C语言中指针的内容是同样重要的，要开发一个程序并不难，但是优秀的程序则更测重于内存管理，它们往往占用内存更少，运行更加流畅。虽然在新版Xcode引入了ARC，但是很多时候它并不能完全解决你的问题。在Xcode中关闭ARC：项目属性—Build Settings--搜索“garbage”找到Objective-C Automatic Reference Counting设置为No即可。

内存管理原理

我们都知道在C#、Java中都有GC在自动管理内存，当我们实例化一个对象之后通常会有一个变量来引用这个对象（变量中存储对象地址），当这个引用变量不再使用之后（也就是不再引用这个对象）此时GC就会自动回收这个对象，简单的说就是：当一个对象没有任何变量引用的时候就会被回收。

例如下面的C#代码片段

using System;

namespace GC
{
    class Program
    {
        private static void Test()
        {
            object o=new object();
        }

        static void Main(string[] args)
        {
            Test();
        }
    }
}

上面是一段C#代码，在Test()方法中，通过new Object()创建了一个对象，o是一个对象的引用（存储了对象的地址），它是一个局部变量，作用范围就是Test()方法内部。

当执行完Test()方法之后o就会被释放，此时由于没有变量在引用new Object()这个对象，因此GC会自动回收这个对象所占用的空间。

但是在ObjC中没有垃圾回收机制，那么ObjC中内存又是如何管理的呢？其实在ObjC中内存的管理是依赖对象引用计数器来进行的：在ObjC中每个对象内部都有一个与之对应的整数（retainCount），叫“引用计数器”，当一个对象在创建之后它的引用计数器为1，当调用这个对象的alloc、retain、new、copy方法之后引用计数器自动在原来的基础上加1（ObjC中调用一个对象的方法就是给这个对象发送一个消息），当调用这个对象的release方法之后它的引用计数器减1，如果一个对象的引用计数器为0，则系统会自动调用这个对象的dealloc方法来销毁这个对象。

下面通过一个简单的例子看一下引用计数器的知识：

Person.h

//
//  Person.h
//  MemoryManage
//
//  Kenshin Cui on 14-2-15.
//  Copyright (c) 2014年 Kenshin Cui. All rights reserved.
//

#import <Foundation/Foundation.h>

@interface Person : NSObject

#pragma mark - 属性
@property (nonatomic,copy) NSString *name;
@property (nonatomic,assign) int age;

@end

Person.m

//
//  Person.m
//  MemoryManage
//
//  Kenshin Cui on 14-2-15.
//  Copyright (c) 2014年 Kenshin Cui. All rights reserved.
//

#import "Person.h"

@implementation Person

#pragma mark - 覆盖方法
#pragma mark 重写dealloc方法，在这个方法中通常进行对象释放操作
-(void)dealloc{
    NSLog(@"Invoke Person's dealloc method.");
    [super dealloc];//注意最后一定要调用父类的dealloc方法（两个目的：一是父类可能有其他引用对象需要释放；二是：当前对象真正的释放操作是在super的dealloc中完成的）
}

@end

main.m

//
//  main.m
//  MemoryManage
//
//  Created by Kenshin Cui on 14-2-15.
//  Copyright (c) 2014年 Kenshin Cui. All rights reserved.
//

#import <Foundation/Foundation.h>
#import "Person.h"

void Test1(){
    Person *p=[[Person alloc]init]; //调用alloc，引用计数器+1
    p.name=@"Kenshin";
    p.age=28;

    NSLog(@"retainCount=%lu",[p retainCount]);
    //结果：retainCount=1

    [p release];
    //结果：Invoke Person's dealloc method.

    //上面调用过release方法，p指向的对象就会被销毁，但是此时变量p中还存放着Person对象的地址，
    //如果不设置p=nil，则p就是一个野指针，它指向的内存已经不属于这个程序，因此是很危险的
    p=nil;
    //如果不设置p=nil，此时如果再调用对象release会报错，但是如果此时p已经是空指针了，
    //则在ObjC中给空指针发送消息是不会报错的
    [p release];
}

void Test2(){
    Person *p=[[Person alloc]init];
    p.name=@"Kenshin";
    p.age=28;

    NSLog(@"retainCount=%lu",[p retainCount]);
    //结果：retainCount=1

    [p retain];//引用计数器+1
    NSLog(@"retainCount=%lu",[p retainCount]);
    //结果：retainCount=2

    [p release];//调用1次release引用计数器-1
    NSLog(@"retainCount=%lu",[p retainCount]);
    //结果：retainCount=1
    [p release];
    //结果：Invoke Person's dealloc method.
    p=nil;
}

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Test1();
    }
    return 0;
}

在上面的代码中我们可以通过dealloc方法来查看是否一个对象已经被回收，如果没有被回收则有可能造成内存泄露。如果一个对象被释放之后，那么最后引用它的变量我们手动设置为nil，否则可能造成野指针错误，而且需要注意在ObjC中给空对象发送消息是不会引起错误的。

野指针错误形式在Xcode中通常表现为：Thread 1：EXC_BAD_ACCESS(code=EXC_I386_GPFLT)错误。因为你访问了一块已经不属于你的内存。

内存释放的原则

手动管理内存有时候并不容易，因为对象的引用有时候是错综复杂的，对象之间可能互相交叉引用，此时需要遵循一个法则：谁创建，谁释放。

假设现在有一个人员Person类，每个Person可能会购买一辆汽车Car，通常情况下购买汽车这个活动我们可能会单独抽取到一个方法中，同时买车的过程中我们可能会多看几辆来最终确定理想的车，现在我们的代码如下：

Car.h

//
//  Car.h
//  MemoryManage
//
//  Created by Kenshin Cui on 14-2-15.
//  Copyright (c) 2014年 Kenshin Cui. All rights reserved.
//

#import <Foundation/Foundation.h>

@interface Car : NSObject

#pragma mark - 属性
#pragma mark 车牌号
@property (nonatomic,copy) NSString *no;

#pragma mark - 公共方法
#pragma mark 运行方法
-(void)run;

@end

Car.m

//
//  Car.m
//  MemoryManage
//
//  Created by Kenshin Cui on 14-2-15.
//  Copyright (c) 2014年 Kenshin Cui. All rights reserved.
//

#import "Car.h"

@implementation Car

#pragma mark - 公共方法
#pragma mark 运行方法
-(void)run{
    NSLog(@"Car(%@) run.",self.no);
}

#pragma mark - 覆盖方法
#pragma mark 重写dealloc方法
-(void)dealloc{

    NSLog(@"Invoke Car(%@) dealloc method.",self.no);
    [super dealloc];
}
@end

Person.h

//
//  Person.h
//  MemoryManage
//
//  Created by Kenshin Cui on 14-2-15.
//  Copyright (c) 2014年 Kenshin Cui. All rights reserved.
//

#import <Foundation/Foundation.h>
@class Car;

@interface Person : NSObject{
    Car *_car;
}

#pragma mark - 属性
#pragma mark 姓名
@property (nonatomic,copy) NSString *name;

#pragma mark - 公共方法
#pragma mark Car属性的set方法
-(void)setCar:(Car *)car;
#pragma mark  Car属性的get方法
-(Car *)car;
@end

Person.m

//
//  Person.m
//  MemoryManage
//
//  Created by Kenshin Cui on 14-2-15.
//  Copyright (c) 2014年 Kenshin Cui. All rights reserved.
//

#import "Person.h"
#import "Car.h"

@implementation Person

#pragma mark - 公共方法
#pragma mark Car属性的set方法
-(void)setCar:(Car *)car{
    if (_car!=car) { //首先判断要赋值的变量和当前成员变量是不是同一个变量
        [_car release]; //释放之前的对象
        _car=[car retain];//赋值时重新retain
    }
}
#pragma mark  Car属性的get方法
-(Car *)car{
    return _car;
}

#pragma mark - 覆盖方法
#pragma mark 重写dealloc方法
-(void)dealloc{
    NSLog(@"Invoke Person(%@) dealloc method.",self.name);
    [_car release];//在此释放对象，即使没有赋值过由于空指针也不会出错
    [super dealloc];
}
@end

main.m

//
//  main.m
//  MemoryManage
//
//  Created by Kenshin Cui on 14-2-15.
//  Copyright (c) 2014年 Kenshin Cui. All rights reserved.
//

#import <Foundation/Foundation.h>
#import "Person.h"
#import "Car.h"

void getCar(Person *p){
    Car *car1=[[Car alloc]init];
    car1.no=@"888888";

    p.car=car1;

    NSLog(@"retainCount(p)=%lu",[p retainCount]);

    Car *car2=[[Car alloc]init];
    car2.no=@"666666";

    [car1 release];
    car1=nil;

    [car2 release];
    car2=nil;
}

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Person *p=[[Person alloc]init];
        p.name=@"Kenshin";

        getCar(p);

        [p.car run];

        [p release];

        p=nil;

    }
    return 0;
}

程序运行结果：

从运行结果来看创建的三个对象p、car1、car2都被回收了，而且[p.car run]也能顺利运行，已经达到了我们的需求。但是这里需要重点解释一下setCar方法的实现,setCar方法中为什么没有写成如下形式：

-(void)setCar:(Car *)car{
    _car=car;
}

前面在我们说到属性的定义时不是都采用的这种方式吗？

根据前面说到的内存释放原则，getCar方法完全符合，在这个方法中定义的两个对象car1、car2也都是在这个方法中释放的，包括main函数中的p对象也是在main函数中定义和释放的。但是如果发现调用完getCar方法之后紧接着调用了汽车的run方法，当然这在程序设计和开发过程中应该是再普通不过的设计了。如果setCar写成“_car=car”的形式，当调用完getCar方法后，人员的car属性被释放了，此时调用run方法是会报错的（大家自己可以试试）。但是如下的方式却不会有问题：

-(void)setCar:(Car *)car{
    if (_car!=car) { //首先判断要赋值的变量和当前成员变量是不是同一个变量
        [_car release]; //释放之前的对象
        _car=[car retain];//赋值时重新retain
    }
}

因为在这个方法中我们通过[car retain]保证每次属性赋值的时候对象引用计数器+1,这样一来调用过getCar方法可以保证人员的car属性不会被释放，其次为了保证上一次的赋值对象（car1）能够正常释放，我们在赋新值之前对原有的值进行release操作。最后在Person的dealloc方法中对_car进行一次release操作（因为setCar中做了一次retain操作）保证_car能正常回收。

属性参数

像上面这样编写setCar方法的情况是比较多的，那么如何使用@property进行自动实现呢？答案就是使用属性参数，例如上面car属性的setter方法，可以通过@property定义如下：

@property (nonatomic,retain) Car *car;

你会发现此刻我们不必手动实现car的getter、setter方法程序仍然没有内存泄露。其实大家也应该都已经看到前面Person的name属性定义的时候我们同样加上了（nonatomic,copy）参数，这些参数到底是什么意思呢？

@property的参数分为三类，也就是说参数最多可以有三个，中间用逗号分隔，每类参数可以从上表三类参数中人选一个。如果不进行设置或者只设置其中一类参数，程序会使用三类中的各个默认参数，默认参数：(atomic,readwrite,assign)

一般情况下如果在多线程开发中一个属性可能会被两个及两个以上的线程同时访问，此时可以考虑atomic属性，否则建议使用nonatomic，不加锁，效率较高；readwirte方法会生成getter、setter两个方法，如果使用readonly则只生成getter方法；关于set方法处理需要特别说明，假设我们定义一个属性a，这里列出三种方式的生成代码：

assign，用于基本数据类型

-(void)setA:(int)a{
    _a=a;
}

retain，通常用于非字符串对象

-(void)setA:(Car *)a{
    if(_a!=a){
        [_a release];
        _a=[a retain];
    }
}

copy，通常用于字符串对象、block、NSArray、NSDictionary

-(void)setA:(NSString *)a{
    if(_a!=a){
        [_a release];
        _a=[a copy];
    }
}

备注：本文基于MRC进行介绍，ARC下的情况不同，请参阅其他文章，例如ARC下基本数据类型默认的属性参数为(atomic,readwrite,assign)，对象类型默认的属性参数为(atomic,readwrite,strong)

自动释放池

在ObjC中也有一种内存自动释放的机制叫做“自动引用计数”（或“自动释放池”），与C#、Java不同的是，这只是一种半自动的机制，有些操作还是需要我们手动设置的。自动内存释放使用@autoreleasepool关键字声明一个代码块，如果一个对象在初始化时调用了autorelase方法，那么当代码块执行完之后，在块中调用过autorelease方法的对象都会自动调用一次release方法。这样一来就起到了自动释放的作用，同时对象的销毁过程也得到了延迟（统一调用release方法）。看下面的代码：

Person.h

//
//  Person.h
//  MemoryManage
//
//  Created by Kenshin Cui on 14-2-15.
//  Copyright (c) 2014年 Kenshin Cui. All rights reserved.
//

#import <Foundation/Foundation.h>

@interface Person : NSObject

#pragma mark - 属性
#pragma mark 姓名
@property (nonatomic,copy) NSString *name;

#pragma mark - 公共方法
#pragma mark 带参数的构造函数
-(Person *)initWithName:(NSString *)name;
#pragma mark 取得一个对象（静态方法）
+(Person *)personWithName:(NSString *)name;
@end

Person.m

//
//  Person.m
//  MemoryManage
//
//  Created by Kenshin Cui on 14-2-15.
//  Copyright (c) 2014年 Kenshin Cui. All rights reserved.
//

#import "Person.h"

@implementation Person

#pragma mark - 公共方法
#pragma mark 带参数的构造函数
-(Person *)initWithName:(NSString *)name{
    if(self=[super init]){
        self.name=name;
    }
    return self;
}
#pragma mark 取得一个对象（静态方法）
+(Person *)personWithName:(NSString *)name{
    Person *p=[[[Person alloc]initWithName:name] autorelease];//注意这里调用了autorelease
    return p;
}

#pragma mark - 覆盖方法
#pragma mark 重写dealloc方法
-(void)dealloc{
    NSLog(@"Invoke Person(%@) dealloc method.",self.name);
    [super dealloc];
}

@end

main.m

//
//  main.m
//  MemoryManage
//
//  Created by Kenshin Cui on 14-2-15.
//  Copyright (c) 2014年 Kenshin Cui. All rights reserved.
//

#import <Foundation/Foundation.h>
#import "Person.h"

int main(int argc, const char * argv[]) {

    @autoreleasepool {
        Person *person1=[[Person alloc]init];
        [person1 autorelease];//调用了autorelease方法后面就不需要手动调用release方法了
        person1.name=@"Kenshin";//由于autorelease是延迟释放，所以这里仍然可以使用person1

        Person *person2=[[[Person alloc]initWithName:@"Kaoru"] autorelease];//调用了autorelease方法

        Person *person3=[Person personWithName:@"rosa"];//内部已经调用了autorelease，所以不需要手动释放，这也符合内存管理原则，因为这里并没有alloc所以不需要release或者autorelease

        Person *person4=[Person personWithName:@"jack"];
        [person4 retain];
    }
    /*结果：
     Invoke Person(rosa) dealloc method.
     Invoke Person(Kaoru) dealloc method.
     Invoke Person(Kenshin) dealloc method.
     */

    return 0;
}

当上面@autoreleaespool代码块执行完之后，三个对象都得到了释放，但是person4并没有释放，原因很简单，由于我们手动retain了一次，当自动释放池释放后调用四个对的release方法，当调用完person4的release之后它的引用计数器为1，所有它并没有释放（这是一个反例，会造成内存泄露）；autorelase方法将一个对象的内存释放延迟到了自动释放池销毁的时候，因此上面person1，调用完autorelase之后它还存在，因此给name赋值不会有任何问题；在ObjC中通常如果一个静态方法返回一个对象本身的话，在静态方法中我们需要调用autorelease方法，因为按照内存释放原则，在外部使用时不会进行alloc操作也就不需要再调用release或者autorelase，所以这个操作需要放到静态方法内部完成。

对于自动内存释放简单总结一下：

  1. autorelease方法不会改变对象的引用计数器，只是将这个对象放到自动释放池中；
  2. 自动释放池实质是当自动释放池销毁后调用对象的release方法，不一定就能销毁对象（例如如果一个对象的引用计数器>1则此时就无法销毁）；
  3. 由于自动释放池最后统一销毁对象，因此如果一个操作比较占用内存（对象比较多或者对象占用资源比较多），最好不要放到自动释放池或者考虑放到多个自动释放池；
  4. ObjC中类库中的静态方法一般都不需要手动释放，内部已经调用了autorelease方法；
时间： 2024-10-31 22:35:43

iOS开发系列—Objective-C之内存管理的相关文章

《iOS应用开发》——2.3节内存管理

2.3 内存管理 iOS应用开发 我不是吓唬你们.在iOS 5.0系统之前,内存管理毫无疑问是iOS开发最困难的部分.简而言之,问题是这样的.无论何时你创建了一个变量,你就要在内存中给它分配一定的空间.对于局部变量来说,我们通常使用栈上的内存,这些内存是自动管理的,当函数返回时,函数中定义的任何局部变量都会从内存中自动删除. 这听起来很棒,但是栈有两个严重的局限.首先,它的空间非常有限,如果用尽了内存,应用程序就会崩溃.其次,这些变量很难共享.请记住,函数使用值传参和返回.这意味着所有传入函数或

iOS开发系列--网络开发

概览 大部分应用程序都或多或少会牵扯到网络开发,例如说新浪微博.微信等,这些应用本身可能采用iOS开发,但是所有的数据支撑都是基于后台网络服务器的.如今,网络编程越来越普遍,孤立的应用通常是没有生命力的.今天就会给大家介绍这部分内容: Web请求和响应 使用代理方法 简化请求方法 图片缓存 扩展--文件分段下载 扩展--文件上传 NSURLSession 数据请求 文件上传 文件下载 会话 UIWebView 浏览器实现 UIWebView与页面交互 网络状态 目 录 Web请求和响应 使用代理

iOS开发系列--并行开发其实很容易

概览 大家都知道,在开发过程中应该尽可能减少用户等待时间,让程序尽可能快的完成运算.可是无论是哪种语言开发的程序最终往往转换成汇编语言进而解释成机器码来执行.但是机器码是按顺序执行的,一个复杂的多步操作只能一步步按顺序逐个执行.改变这种状况可以从两个角度出发:对于单核处理器,可以将多个步骤放到不同的线程,这样一来用户完成UI操作后其他后续任务在其他线程中,当CPU空闲时会继续执行,而此时对于用户而言可以继续进行其他操作:对于多核处理器,如果用户在UI线程中完成某个操作之后,其他后续操作在别的线程

iOS开发系列--Swift语言

概述 Swift是苹果2014年推出的全新的编程语言,它继承了C语言.ObjC的特性,且克服了C语言的兼容性问题.Swift发展过程中不仅保留了ObjC很多语法特性,它也借鉴了多种现代化语言的特点,在其中你可以看到C#.Java.Javascript.Python等多种语言的影子.同时在2015年的WWDC上苹果还宣布Swift的新版本Swift2.0,并宣布稍后Swift即将开源,除了支持iOS.OS X之外还将支持linux. 本文将继续iOS开发系列教程,假设读者已经有了其他语言基础(强烈

iOS开发系列--数据存取

概览 在iOS开发中数据存储的方式可以归纳为两类:一类是存储为文件,另一类是存储到数据库.例如前面IOS开发系列-Objective-C之Foundation框架的文章中提到归档.plist文件存储,包括偏好设置其本质都是存储为文件,只是说归档或者plist文件存储可以选择保存到沙盒中,而偏好设置系统已经规定只能保存到沙盒的Library/Preferences目录.当然,文件存储并不作为本文的重点内容.本文重点还是说数据库存储,做过数据库开发的朋友应该知道,可以通过SQL直接访问数据库,也可以

iOS开发系列--详细介绍数据存取_IOS

概览 在iOS开发中数据存储的方式可以归纳为两类:一类是存储为文件,另一类是存储到数据库.例如前面IOS开发系列-Objective-C之Foundation框架的文章中提到归档.plist文件存储,包括偏好设置其本质都是存储为文件,只是说归档或者plist文件存储可以选择保存到沙盒中,而偏好设置系统已经规定只能保存到沙盒的Library/Preferences目录.当然,文件存储并不作为本文的重点内容.本文重点还是说数据库存储,做过数据库开发的朋友应该知道,可以通过SQL直接访问数据库,也可以

iOS开发系列--让你的应用“动”起来

概览 在iOS中随处都可以看到绚丽的动画效果,实现这些动画的过程并不复杂,今天将带大家一窥iOS动画全貌.在这里你可以看到iOS中如何使用图层精简非交互式绘图,如何通过核心动画创建基础动画.关键帧动画.动画组.转场动画,如何通过UIView的装饰方法对这些动画操作进行简化等.在今天的文章里您可以看到动画操作在iOS中是如何简单和高效,很多原来想做但是苦于没有思路的动画在iOS中将变得越发简单: CALayer CALayer简介 CALayer常用属性 CALayer绘图 Core Animat

iOS开发系列--通知与消息机制

概述 在多数移动应用中任何时候都只能有一个应用程序处于活跃状态,如果其他应用此刻发生了一些用户感兴趣的那么通过通知机制就可以告诉用户此时发生的事情.iOS中通知机制又叫消息机制,其包括两类:一类是本地通知:另一类是推送通知,也叫远程通知.两种通知在iOS中的表现一致,可以通过横幅或者弹出提醒两种形式告诉用户,并且点击通知可以会打开应用程序,但是实现原理却完全不同.今天就和大家一块去看一下如何在iOS中实现这两种机制,并且在文章后面会补充通知中心的内容避免初学者对两种概念的混淆. 本地通知 推送通

iOS开发系列--C语言之基础知识

当前移动开发的趋势已经势不可挡,这个系列希望浅谈一下个人对IOS开发的一些见解,这个IOS系列计划从几个角度去说IOS开发: C语言 OC基础 IOS开发(iphone/ipad) Swift 这么看下去还有大量的内容需要持续补充,但是今天我们从最基础的C语言开始,C语言部分我将分成几个章节去说,今天我们简单看一下C的一些基础知识,更高级的内容我将放到后面的文章中. 今天基础知识分为以下几点内容(注意:循环.条件语句在此不再赘述): Hello World 运行过程 数据类型 运算符 常用函数

iOS夯实：ARC时代的内存管理

iOS夯实:ARC时代的内存管理 什么是ARC Automatic Reference Counting (ARC) is a compiler feature that provides automatic memory management of Objective-C objects. Rather than having to think about retain and release operations [^1] [^1]: Transitioning to ARC Release