ObjectiveC内存管理课件.docx
《ObjectiveC内存管理课件.docx》由会员分享，可在线阅读，更多相关《ObjectiveC内存管理课件.docx（15页珍藏版）》请在冰豆网上搜索。
ObjectiveC内存管理课件
Objective-C的内存管理机制琢磨不透
初学objectice-C的朋友都有一个困惑，总觉得对objective-C的内存管理机制琢磨不透，程序经常内存泄漏或莫名其妙的崩溃。
Objective-C2.0增加了一些新的东西，包括属性和垃圾回收。
那么，我们在学习Objective-C2.0之前，最好应该先了解，从前是什么样的，为什么Objective-C2.0要增加这些支持。
这一切都跟Cocoa内存的管理规则有关系，我们知道，Objective-C中所有变量都定义为指针。
指针是一个特殊的变量，它里面存储的数值被解释成为内存里的一个地址，如果使用不当，就会出错或者造成内存的泄露。
要了解这些，就需要看看其内存管理的规则到底是什么样的。
Cocoa和Objective-C的类都是NSObject的子类。
NSObject中有几个方法进行内存管理。
alloc方法为对象分配一片内存空间。
dealloc方法用于释放对象的空间。
但是在我们的代码中将永远都不会使用dealloc方法（类似C++中的析构函数），因为运行时会为你调用此方法释放内存空间。
而你需要做的只是引用计数。
1．Objectreleaseandreferencecount
Objective-C的对象在使用完成之后不会自动销毁，需要执行dealloc来释放空间（销毁），否则内存泄露。
[obj1release];//release方法来自动调用对象的dealloc方法
这带来了一个问题。
下面代码中obj2是否需要调用dealloc？
ClassA*obj1=[[ClassAalloc]init];
ClassA*obj2=obj1;
[obj1hello];//输出hello
[obj1release];
[obj2hello];//能够执行这一行和下一行吗？
[obj2release];
不能，因为obj1和obj2只是指针，它们指向同一个对象，[obj1dealloc]已经销毁这个对象了，不能再调用[obj2hello]和[obj2release]。
obj2实际上是个无效指针。
Objective-C采用了引用计数（retaincount）。
对象的内部保存一个数字，表示被引用的次数。
例如，某个对象被两个指针所指向（引用）那么它的retaincount为2。
需要销毁对象的时候，不直接调用dealloc，而是调用release。
release会让retaincount减1，只有retaincount等于0，系统才会调用dealloc真正销毁这个对象。
Foo * myFooOne = [[Foo alloc] init]; //retaincount 为1
1.
2.Foo * myFooTwo = myFooOne; //myFooTwo 指向了这个对象
3.
4.//retaincount 仍然为1
5.
6.[myFooTwo retain]; //调用retain方法，运行时才知道myFooTwo指向了该对象,retaincount 为2
上面的代码中，myFooTwo通过调用retain方法，取得了Foo对象的拥有权。
在这个对象的生命周期中，会有很多变量来指向和引用它。
指向这个对象的变量也可以通过release方法来解除这种拥有权。
release方法将会告诉运行时，我已经使用完这个变量了，已经不需要它了，retainCount计数减1。
当对象的retainCount的计数大于或者等于1的时候，运行时会继续维持这个对象。
当对象的retainCount为0的时候，运行时会释放这个对象，并回收它占得内存空间。
[myFooOnerelease];//[myFooOneretaincount]=1;//[myFooTwo retaincount]=1;
[myFooOnerelease];//[myFooOneretaincount]=0;//[myFooTwo retaincount]=0;
2.autoreleasepool
Objective-C中引入了autoreleasepool（自动释放对象池），在遵守一些规则的情况下，可以自动释放对象。
新生成的对象，只要调用autorelease就行了，无需再调用release！
ClassA*obj1=[[[ClassAalloc]init]autorelease];
//retaincount=1但无需调用release
对于存在指针赋值的情况，代码与前面类似。
ClassA*obj1=[[[ClassAalloc]init]autorelease];
//retaincount=1
ClassA*obj2=obj1;//retaincount=1
[obj2retain];//retaincount=2
[obj1hello];//输出hello
//对于obj1，无需调用（实际上不能调用）release
[obj2hello];//输出hello
[obj2release];//retaincount=2-1=1
autoreleasepool原理剖析。
（其实很简单的，一定要坚持看下去，否则还是不能理解Objective-C的内存管理机制。
）autoreleasepool不是天生的，需要手动创立。
只不过在新建一个iphone项目时，xcode会自动帮你写好。
autoreleasepool的真名是NSAutoreleasePool。
NSAutoreleasePool*pool=[[NSAutoreleasePoolalloc]init];
NSAutoreleasePool内部包含一个数组（NSMutableArray），用来保存声明为autorelease的所有对象。
如果一个对象声明为autorelease，系统所做的工作就是把这个对象加入到这个数组中去。
ClassA*obj1=[[[ClassAalloc]init]autorelease];//retaincount=1
把此对象加入autoreleasepool中NSAutoreleasePool自身在销毁的时候，会遍历一遍这个数组，release数组中的每个成员。
如果此时数组中成员的retaincount为1，那么release之后，retaincount为0，对象正式被销毁。
如果此时数组中成员的retaincount大于1，那么release之后，retaincount大于0，此对象依然没有被销毁，内存泄露。
默认只有一个autoreleasepool，通常类似于下面这个例子。
intmain（intargc,constchar*argv[]）
{
NSAutoreleasePool*pool;
pool=[[NSAutoreleasePoolalloc]init];
//dosomething
[poolrelease];
return（0）;
}//main
所有标记为autorelease的对象都只有在这个pool销毁时才被销毁。
如果你有大量的对象标记为autorelease，这显然不能很好的利用内存，在iphone这种内存受限的程序中是很容易造成内存不足的。
例如：
intmain（intargc,constchar*argv[]）
{
NSAutoreleasePool*pool=[[NSAutoreleasePoolalloc]init];
inti,j;
for（i=0;i<100;i++）
{
for（j=0;j<100000;j++）
[NSStringstringWithFormat:
@"1234567890"];//产生的对象是autorelease的。
}
[poolrelease];
return（0）;
}//main
二口诀与范式
1．口诀
1.1谁创建，谁释放（类似于“谁污染，谁治理”）。
如果你通过alloc、new或copy来创建一个对象，那么你必须调用release或autorelease。
换句话说，不是你创建的，就不用你去释放。
例如，你在一个函数中alloc生成了一个对象，且这个对象只在这个函数中被使用，那么你必须在这个函数中调用release或autorelease。
如果你在一个class的某个方法中alloc一个成员对象，且没有调用autorelease，那么你需要在这个类的dealloc方法中调用release；如果调用了autorelease，那么在dealloc方法中什么都不需要做。
1.2除了alloc、new或copy之外的方法创建的对象都被声明了autorelease。
1.3谁retain，谁release。
只要你调用了retain，无论这个对象是如何生成的，你都要调用release。
有时候你的代码中明明没有retain，可是系统会在默认实现中加入retain。
不知道为什么苹果公司的文档没有强调这个非常重要的一点，请参考范式2.7和第三章。
2．范式
范式就是模板，就是依葫芦画瓢。
由于不同人有不同的理解和习惯，我总结的范式不一定适合所有人，但我能保证照着这样做不会出问题。
2.1创建一个对象。
ClassA*obj1=[[ClassAalloc]init];
2.2创建一个autorelease的对象。
ClassA*obj1=[[[ClassAalloc]init]autorelease];
2.3Release一个对象后，立即把指针清空。
（顺便说一句，release一个空指针是合法的，但不会发生任何事情）
[obj1release];
obj1=nil;
2.4指针赋值给另一个指针。
ClassA*obj2=obj1;
[obj2retain];
//dosomething
[obj2release];
obj2=nil;
2.5在一个函数中创建并返回对象，需要把这个对象设置为autorelease
ClassA*Func1（）
{
ClassA*obj=[[[ClassAalloc]init]autorelease];
returnobj;
}
2.6在子类的dealloc方法中调用基类的dealloc方法
-（void）dealloc
{
…
[superdealloc];
}
2.7在一个class中创建和使用property。
2.7.1声明一个成员变量。
ClassB*objB;
2.7.2声明property，加上retain参数。
@property（retain）ClassB*objB;
2.7.3定义property。
（property的默认实现请看第三章）
@synthesizeobjB;
2.7.4除了dealloc方法以外，始终用.操作符的方式来调用property。
self.objB或者objA.objB
2.7.5在dealloc方法中release这个成员变量。
[objBrelease];
@interfaceClassA:
NSObject
{
ClassB*objB;
}
@property（retain）ClassB*objB;
@end
@implementationClassA
@synthesizeobjB;
-（void）dealloc
{
[objBrelease];
[superdealloc];
}
@end
2.7.6给这个property赋值时，有手动release和autorelease两种方式。
voidfuncNoAutorelease（）
{
ClassB*objB1=[[ClassBalloc]init];
ClassA*objA=[[ClassAalloc]init];
objA.objB=objB1;
[objB1release];
[objArelease];
}
voidfuncAutorelease（）
{
ClassB*objB1=[[[ClassBalloc]init]autorelease];
ClassA*objA=[[[ClassAalloc]init]autorelease];
objA.objB=objB1;
}
三@property（retain）和@synthesize的默认实现
在这里解释一下@property（retain）ClassB*objB;和@synthesizeobjB;背后到底发生了什么（retainproperty的默认实现）。
property实际上是getter和setter，针对有retain参数的property，背后的实现如下：
@interfaceClassA:
NSObject
{
ClassB*objB;
}
-（ClassB*）objB;
-（void）setObjB:
（ClassB*）value;
@end
@implementationClassA
-（ClassB*）objB
{
returnobjB;
}
-（void）setObjB:
（ClassB*）value
{
if（objB!
=value）
{
[objBrelease];
objB=[valueretain];
}
}
在setObjB中，如果新设定的值和原值不同的话（如果相同怎么办？
可以测试一下），必须要把原值对象release一次，这样才能保证retaincount是正确的。
由于我们在class内部retain了一次（虽然是默认实现的），所以我们要在dealloc方法中release这个成员变量。
-（void）dealloc
{
[objBrelease];
[superdealloc];
}
property中使用assign,retain,copy的区别（需要先讲一下copy协议）
//MyPoint.h
#import
@interfaceMyPoint:
NSObject{
intx;
inty;
}
@property（nonatomic）intx,y;
-（void）setMyPoint:
（int）_xandY:
（int）_y;
@end
//MyPoint.m
#import"MyPoint.h"
@implementationMyPoint
@synthesizex,y;
-（void）setMyPoint:
（int）_xandY:
（int）_y{
x=_x;
y=_y;
}
@end
//Circle.h
#import
#import"MyPoint.h"
@interfaceCircle:
NSObject{
MyPoint*p;
intradius;
}
@property（nonatomic,assign）MyPoint*p;
-（id）initP:
（MyPoint*）_pandRad:
（int）_r;
-（void）print;
@end
//Circle.m
#import"Circle.h"
@implementationCircle
@synthesizep;
-（id）initP:
（MyPoint*）_pandRad:
（int）_r{
//初始化第一步
if（_r<0）
{
radius=1;
}
if（_p==nil）//#1
{
[selfrelease];
returnnil;
}
//初始化第二步
if（!
（self=[superinit]））//#2
returnnil;
//初始化第三步
//[_pretain];
//p=_p;
if（p）
[prelease];
p=[[MyPointalloc]init];
[psetMyPoint:
_p.xandY:
_p.y];
radius=_r;
returnself;
}
-（void）dealloc
{
[superdealloc];
if（p）{
[prelease];
}
}
-（void）print
{
NSLog（@"r=%d",radius）;
}
@end
intmain（intargc,constchar*argv[]）{
NSAutoreleasePool*pool=[[NSAutoreleasePoolalloc]init];
//insertcodehere...
MyPoint*p=[[MyPointalloc]init];
NSLog（@"P:
%lu",[pretainCount]）;//1
Circle*c=[[Circlealloc]init];
NSLog（@"c:
%lu",[cretainCount]）;//1
[pooldrain];
return0;
}
1,@property（nonatomic,assign）MyPoint*p;
主函数中加入以下代码：
c.p=p;//[c.pretainCount]为多少？
[pretainCount]=？
c.p和p是深拷贝or浅拷贝？
[c.pretainCount]=1？
[pretainCount]=1
浅拷贝，
2，把property中assign找成retain，[c.pretainCount]又为多少？
[pretainCount]？
c.p和p是深拷贝or浅拷贝？
[c.pretainCount]=2？
[pretainCount]=2
浅拷贝，
3，改为copy呢？
[c.pretainCount]=？
[pretainCount]=？
c.p和p是深拷贝or浅拷贝？
[c.pretainCount]=1？
[pretainCount]=1
深拷贝，
4，在主函数中把c.p=p;换成c.p=[pcopy];property属性中分别用assign,retain,copy再进行测试，结果又如何？
中间是否有内存泄露问题？
c.p和p是深拷贝or浅拷贝？
Assign：
[c.pretainCount]=1？
[pretainCount]=1
深拷贝，不会有内存泄露。
Retain：
[c.pretainCount]=2？
[pretainCount]=1
深拷贝，不会有内存泄露。
Copy：
[c.pretainCount]=1？
[pretainCount]=1
深拷贝，会有内存泄露。
5，把-（id）initP:
（MyPoint*）_pandRad:
（int）_r实现中的p的初始化改为p=_p后，再分别重复以上四种情况下[c.pretainCount]和[pretainCount]各是多少？
c.p和p是深拷贝or浅拷贝？
如果初始化方法不变的话，都将不会变。
如果初始化方法换成-（id）initP:
（MyPoint*）_pandRad:
（int）_r
c.p=p;
1）、assign:
[c.pretainCount]=1？
[pretainCount]=1
浅拷贝，
2）、retain:
[c.pretainCount]=1？
[pretainCount]=1
浅拷贝，
3）、copy:
[c.pretainCount]=1？
[pretainCount]=1
深拷贝，
c.p=[pcopy];
1）、assign:
[c.pretainCount]=1？
[pretainCount]=1
浅拷贝
2）、retain:
[c.pretainCount]=2？
[pretainCount]=1
浅拷贝
3）、copy:
[c.pretainCount]=1？
[pretainCount]=1
深拷贝，
升级会员 