Obj-C Memory Management
Memory management is one of the most important process in any programming language. It is the process by which the memory of objects are allocated when they are required and deallocated when they are no longer required.
Managing object memory is a matter of performance; if an application doesn't free unneeded objects, its memory footprint grows and performance suffers.
Objective-C Memory management techniques can be broadly classified into two types.
- "Manual Retain-Release" or MRR
- "Automatic Reference Counting" or ARC
"Manual Retain-Release" or MRR
In MRR, we explicitly manage memory by keeping track of objects on our own. This is implemented using a model, known as reference counting, that the Foundation class NSObject provides in conjunction with the runtime environment.
The only difference between MRR and ARC is that the retain and release is handled by us manually in former while its automatically taken care of in the latter.
The following figure represents an example of how memory management work in Objective-C.
The memory life cycle of the Class A object is shown in the above figure. As you can see, the retain count is shown below the object, when the retain count of an object becomes 0, the object is freed completely and its memory is deallocated for other objects to use.
Class A object is first created using alloc/init method available in NSObject. Now, the retain count becomes 1.
Now, class B retains the Class A's Object and the retain count of Class A's object becomes 2.
Then, Class C makes a copy of the object. Now, it is created as another instance of Class A with same values for the instance variables. Here, the retain count is 1 and not the retain count of the original object. This is represented by the dotted line in the figure.
The copied object is released by Class C using the release method and the retain count becomes 0 and hence the object is destroyed.
In case of the initial Class A Object, the retain count is 2 and it has to be released twice in order for it to be destroyed. This is done by release statements of Class A and Class B which decrements the retain count to 1 and 0, respectively. Finally, the object is destroyed.
MRR Basic Rules
We own any object we create: We create an object using a method whose name begins with "alloc", "new", "copy", or "mutableCopy"
We can take ownership of an object using retain: A received object is normally guaranteed to remain valid within the method it was received in, and that method may also safely return the object to its invoker. We use retain in two situations:
In the implementation of an accessor method or an init method, to take ownership of an object we want to store as a property value.
To prevent an object from being invalidated as a side-effect of some other operation.
When we no longer need it, we must relinquish ownership of an object we own: We relinquish ownership of an object by sending it a release message or an autorelease message. In Cocoa terminology, relinquishing ownership of an object is therefore typically referred to as "releasing" an object.
You must not relinquish ownership of an object you do not own: This is just corollary of the previous policy rules stated explicitly.
#import <Foundation/Foundation.h> @interface SampleClass:NSObject
- (void)sampleMethod;
@end @implementation SampleClass - (void)sampleMethod
{
NSLog(@"Hello, World! \n");
} - (void)dealloc
{
NSLog(@"Object deallocated");
[super dealloc];
} @end int main()
{
/* my first program in Objective-C */
SampleClass *sampleClass = [[SampleClass alloc]init];
[sampleClass sampleMethod];
NSLog(@"Retain Count after initial allocation: %d",
[sampleClass retainCount]);
[sampleClass retain];
NSLog(@"Retain Count after retain: %d", [sampleClass retainCount]);
[sampleClass release];
NSLog(@"Retain Count after release: %d", [sampleClass retainCount]);
[sampleClass release];
NSLog(@"SampleClass dealloc will be called before this");
// Should set the object to nil
sampleClass = nil;
return ;
}
When we compile the above program, we will get the following output.
-- ::52.310 demo[] Hello, World!
-- ::52.311 demo[] Retain Count after initial allocation:
-- ::52.311 demo[] Retain Count after retain:
-- ::52.311 demo[] Retain Count after release:
-- ::52.311 demo[] Object deallocated
-- ::52.311 demo[] SampleClass dealloc will be called before this
"Automatic Reference Counting" or ARC
In Automatic Reference Counting or ARC, the system uses the same reference counting system as MRR, but it inserts the appropriate memory management method calls for us at compile-time. We are strongly encouraged to use ARC for new projects. If we use ARC, there is typically no need to understand the underlying implementation described in this document, although it may in some situations be helpful. For more about ARC, see Transitioning to ARC Release Notes.
As mentioned above, in ARC, we need not add release and retain methods since that will be taken care by the compiler. Actually, the underlying process of Objective-C is still the same. It uses the retain and release operations internally making it easier for the developer to code without worrying about these operations, which will reduce both the amount of code written and the possibility of memory leaks.
There was another principle called garbage collection, which is used in Mac OS-X along with MRR, but since its deprecation in OS-X Mountain Lion, it has not been discussed along with MRR. Also, iOS objects never had garbage collection feature. And with ARC, there is no use of garbage collection in OS-X too.
Here is a simple ARC example. Note this won't work on online compiler since it does not support ARC.
#import <Foundation/Foundation.h> @interface SampleClass:NSObject
- (void)sampleMethod;
@end @implementation SampleClass - (void)sampleMethod
{
NSLog(@"Hello, World! \n");
} - (void)dealloc
{
NSLog(@"Object deallocated");
} @end int main()
{
/* my first program in Objective-C */
@autoreleasepool{
SampleClass *sampleClass = [[SampleClass alloc]init];
[sampleClass sampleMethod];
sampleClass = nil;
}
return ;
}
When we compile the above program, we will get the following output.
-- ::47.310 demo[] Hello, World!
-- ::47.311 demo[] Object deallocated
Obj-C Memory Management的更多相关文章
- Memory Management in Open Cascade
Open Cascade中的内存管理 Memory Management in Open Cascade eryar@163.com 一.C++中的内存管理 Memory Management in ...
- Java (JVM) Memory Model – Memory Management in Java
原文地址:http://www.journaldev.com/2856/java-jvm-memory-model-memory-management-in-java Understanding JV ...
- Objective-C Memory Management
Objective-C Memory Management Using Reference Counting 每一个从NSObject派生的对象都继承了对应的内存管理的行为.这些类的内部存在一个称为r ...
- Operating System Memory Management、Page Fault Exception、Cache Replacement Strategy Learning、LRU Algorithm
目录 . 引言 . 页表 . 结构化内存管理 . 物理内存的管理 . SLAB分配器 . 处理器高速缓存和TLB控制 . 内存管理的概念 . 内存覆盖与内存交换 . 内存连续分配管理方式 . 内存非连 ...
- Android内存管理(2)HUNTING YOUR LEAKS: MEMORY MANAGEMENT IN ANDROID PART 2
from: http://www.raizlabs.com/dev/2014/04/hunting-your-leaks-memory-management-in-android-part-2-of- ...
- Android内存管理(1)WRANGLING DALVIK: MEMORY MANAGEMENT IN ANDROID PART 1
from : http://www.raizlabs.com/dev/2014/03/wrangling-dalvik-memory-management-in-android-part-1-of-2 ...
- Understanding Memory Management(2)
Understanding Memory Management Memory management is the process of allocating new objects and remov ...
- Java Memory Management(1)
Java Memory Management, with its built-in garbage collection, is one of the language’s finest achiev ...
- ural1037 Memory Management
Memory Management Time limit: 2.0 secondMemory limit: 64 MB Background Don't you know that at school ...
- 再谈.net的堆和栈---.NET Memory Management Basics
.NET Memory Management Basics .NET memory management is designed so that the programmer is freed fro ...
随机推荐
- Awesome Flask Awesome
A curated list of awesome Flask resources and plugins Awesome Flask Framework Admin interface Authen ...
- telnet命令发送邮件
下面的例子是用qq的smtp服务器. set localecho 本地回显启用 smtp.qq.com Esmtp QQ Mail Server helo sis smtp.qq.com//服务器返回 ...
- gulp --- 前端自动化构建工具
目录 1. gulp使用步骤 1.1 安装Node.js 1.2 全局安装gulp 1.3 安装项目依赖包gulp 1.3.1 了解package.json 1.3.2 根据package.json安 ...
- MongoDB分析工具之三:db.currentOp()
db.currentOp() db.currentOp是个好东西,顾名思义,就是当前的操作.在mongodb中可以查看当前数据库上此刻的操作语句信息,包括insert/query/update/rem ...
- view-source协议
转自;https://blog.csdn.net/yuwq123/article/details/79481829
- art-template在项目中的应用
art-template 是一个简约.超快的模板引擎.它采用作用域预声明的技术来优化模板渲染速度,从而获得接近 JavaScript 极限的运行性能,并且同时支持 NodeJS 和浏览器. 下面介绍在 ...
- CodeForces水题
CodeForces754A 题意: 给一个数组,让你变成1-n,输出变换区间,要求原区间和不为0. 思路: 如果原数组不为0,那就是YES: 如果为0,则从1开始扫过去,碰到不为0时,分两个区间[1 ...
- CodeForces 363D 【二分+贪心】
思路: 一开始是没有办法贪心的,但是答案是可以二分的,因为窝能买k辆车的话,窝就一定能买k-1辆车:而且我最好就是拿手上钱较多的那些人去买价格便宜的车,这样肯定是能买到最多的车,而且花的少,因为对于要 ...
- 学习RESTFul架构
一.RESTFul介绍 1.一种软件架构风格,设计风格而不是标准,只是提供了一组设计原则和约束条件.它主要用于客户端和服务器交互类的软件.基于这个风格设计的软件可以更简洁,更有层次,更易于实现缓存等机 ...
- button 获取 cell
- (void)cellBtnClicked:(id)sender event:(id)event { NSSet *touches =[event allTouches]; ...