内存管理/run time机制

作者: 承宇 | 来源:发表于2015-11-04 20:05 被阅读678次

Tables	Are	PS
1	基本原理
1.1	为什么要进行内存管理
1.2	对象的基本结构
1.3	引用计数器的作用
1.4	操作
1.5	对象的销毁
2	相关概念和使用注意
3	内存管理原则
3.1	原则
3.2	多对象管理
4	内存管理代码规范
4.1	基本数据类型
4.2	内存管理代码规范
4.2	dealloc方法的代码规范
5	@property的参数
5.1	内存管理相关参数
5.2	set和get方法的名称
6	内存管理中的循环引用问题以及解决
7	Autorelease
7.1	基本用法
7.2	好处
7.3	错误写法
7.4	自动释放池
7.5	使用注意
8	ARC内存管理机制
8.1	ARC的判断准则
8.2	指针分类
8.3	ARC的特点总结
8.4	NSString的retainCount
8.4	补充
9	runtime 机制
9.1	run time 相关原理
9.2	runtime 的相关实现

内存分配
instruments 里面的leaks和allocation

OC 内存管理

1.基本原理

1.1 为什么要进行内存管理

由于移动设备的内存极其有限，所以每个APP所占的内存也是有限制的，当app所占用的内存较多时，系统就会发出内存警告，这时需要回收一些不需要再继续使用的内存空间，比如回收一些不再使用的对象和变量等。
下列行为都会增加一个app的内存占用

创建一个OC对象
定义一个变量
调用一个函数或者方法

管理范围：任何继承NSObject的对象，对其他的基本数据类型无效。
本质原因是因为对象和其他数据类型在系统中的存储空间不一样，其它局部变量主要存放于栈中，而对象存储于堆中，当代码块结束时这个代码块中涉及的所有局部变量会被回收，指向对象的指针也被回收.此时对象已经没有指针指向，要是依然存在于内存中，会造成内存泄露。

1.2 对象的基本结构

每个OC对象都有自己的引用计数器，是一个整数表示对象被引用的次数，即现在有多少东西在使用这个对象。对象刚被创建时，默认计数器值为1，当计数器的值变为0时，则对象销毁。
在每个OC对象内部，都专门有4个字节的存储空间来存储引用计数器。

1.3 引用计数器的作用

判断对象要不要回收的唯一依据就是计数器是否为0，若不为0则存在。为0则调用dealloc函数。

1.4 操作

给对象发送消息，进行相应的计数器操作。
Retain消息：使计数器+1，改方法返回对象本身
Release消息：使计数器-1（并不代表释放对象）
retainCount消息：获得对象当前的引用计数器值

1.5 对象的销毁

当一个对象的引用计数器为0时，那么它将被销毁，其占用的内存被系统回收。
当对象被销毁时，系统会自动向对象发送一条dealloc消息，一般会重写dealloc方法，在这里释放相关的资源，dealloc就像是对象的“临终遗言”。一旦重写了dealloc方法就必须调用[super dealloc]，并且放在代码块的最后调用（不能直接调用dealloc方法）。
一旦对象被回收了，那么他所占据的存储空间就不再可用，坚持使用会导致程序崩溃（野指针错误）。

2.相关概念和使用注意

野指针错误：访问了一块坏的内存（已经被回收的，不可用的内存）。
僵尸对象：所占内存已经被回收的对象，僵尸对象不能再被使用。（打开僵尸对象检测）

空指针：没有指向任何东西的指针（存储的东西是0,null，nil），给空指针发送消息不会报错
注意：不能使用[p retaion]让僵尸对象起死复生。

3.内存管理原则

3.1原则

只要还有人在使用某个对象，那么这个对象就不会被回收；
只要你想使用这个对象，那么就应该让这个对象的引用计数器+1；
当你不想使用这个对象时，应该让对象的引用计数器-1；

谁创建，谁release
如果你通过alloc,new,copy来创建了一个对象，那么你就必须调用release或者autorelease方法
不是你创建的就不用你去负责
谁retain，谁release**
只要你调用了retain，无论这个对象时如何生成的，你都要调用release
总结
有始有终，有加就应该有减。曾经让某个对象计数器加1，就应该让其在最后-1.

3.2 多对象管理

单个对象的内存管理, 看起来非常简单。如果对多个对象进行内存管理, 并且对象之间是有联系的, 那么管理就会变得比较复杂

其实, 多个对象的管理思路跟很多游戏的房间管理差不多
比如斗地主 \ QQ堂

有一个房间，有人要用，一号使用retaincount+1 ，release下，二号使用同理。当没人使用的话，释放房间
总的来说, 有这么几点管理规律

只要还有人在用某个对象，那么这个对象就不会被回收
只要你想用这个对象，就让对象的计数器+1
当你不再使用这个对象时，就让对象的计数器-1

4.内存管理代码规范

只要调用了alloc，就必须有release(autorelease)

4.1 基本数据类型：直接复制

-（void）setAge:(int)age
{
_age=age;
}

4.2 OC对象类型

-（void）setCar:(Car *)car
{
//1.先判断是不是新传进来的对象
If(car!=_car)
{
//2 对旧对象做一次release
[_car release];//若没有旧对象，则没有影响
//3.对新对象做一次retain
_car=[car retain];
}
}

4.3 dealloc方法的代码规范

一定要[super dealloc]，而且要放到最后
对self（当前）所拥有的的其他对象做一次release操作

-（void）dealloc
{
[_car release];
[super dealloc];
}

下面代码都会引发内存泄露

p.dog = [[Dog alloc] init];

[[Dog alloc] init].weight = 20.8;

5. @property的参数

5.1内存管理相关参数

Retain:对对象release旧值，retain新值（适用于OC对象类型）完整的set方法，管理内存的参数
Assign:直接赋值（默认，不写参数的都是assign，适用于非oc对象类型，这样对位于栈的系统自动生成的变量）
Copy:release旧值，copy新值,用于NSString\block等类型

ARC中的@property
strong : 用于OC对象, 相当于MRC中的retain
weak : 用于OC对象, 相当于MRC中的assign
assign : 用于基本数据类型, 跟MRC中的assign一样
copy : 一般用于NSString, 跟MRC中的copy一样

是否要生成set方法（若为只读属性，则不生成）
Readonly:只读，只会生成getter的声明和实现
Readwrite:默认的，同时生成setter和getter的声明和实现

多线程管理（苹果在一定程度上屏蔽了多线程操作）
Nonatomic:高性能，一般使用这个
Atomic:低性能

5.2 Set和get方法的名称

修改set和get方法的名称，主要用于布尔类型。因为返回布尔类型的方法名一般以is开头，修改名称一般用在布尔类型中的getter。
@propery(setter=setAbc,getter=isRich) BOOL rich;
BOOL b=p.isRich;// 调用

6. 内存管理中的循环引用问题以及解决

案例：每个人有一张身份证，每张身份证对应一个人，不能使用#import的方式相互包含，这就形成了循环引用。
新的关键字：
@class 类名；——解决循环引用问题，提高性能；
@class仅仅告诉编译器，在进行编译的时候把后面的名字作为一个类来处理。
@class的作用：声明一个类，告诉编译器某个名称是一个类

那么我们怎么使用@class，

在.h文件中使用@class来声明类
在.m文件中真正要使用到的时候，使用#import来包含类中的所有东西

两端循环引用的解决方法

循环retain的场景
比如A对象retain了B对象，B对象retain了A对象

循环retain的弊端
这样会导致A对象和B对象永远无法释放

循环retain的解决方案
当两端互相引用时，应该一端用retain、一端用assign（使用assign的在dealloc中也不用再release）

7 Autorelease

7.1 基本用法

会将对象放到一个自动释放池中
当自动释放池被销毁时，会对池子里的所有对象做一次release
会返回对象本身
调用完autorelease方法后，对象的计数器不受影响（销毁时影响）

7.2 好处

不需要再关心对象释放的时间
不需要再关心什么时候调用release

7.3 错误写法

连续调用多次autorelease，释放池销毁时执行两次release(-1吗？)

Alloc之后调用了autorelease，之后又调用了release。

7.4 自动释放池

在ios程序运行过程中，会创建无数个池子，这些池子都是以栈结构（先进后出）存在的。
当一个对象调用autorelease时，会将这个对象放到位于栈顶的释放池中

7.5 Autorelease注意

系统自带的方法中，如果不包含alloc new copy等，则这些方法返回的对象都是autorelease的，如[NSDate date]；
开发中经常会写一些类方法来快速创建一个autorelease对象，创建对象时不要直接使用类名，而是使用self
占用内存较大的对象，不要随便使用autorelease，应该使用release来精确控制;而占用内存较小的对象使用autorelease，没有太大的影响

8. ARC内存管理机制

8.1 ARC的判断准则

只要没有强指针指向对象，对象就会被释放。

8.2 指针分类

强指针：默认的情况下，所有的指针都是强指针，关键字strong
弱指针：___weak关键字修饰的指针

声明一个弱指针如下：___weak Person *p;
ARC中，只要弱指针指向的对象不在了，就直接把弱指针做清空操作。

___weak Person * p= [[Person alloc] init];

不合理，对象一创建出来就被释放掉，对象释放掉后，ARC把指针自动清零。
ARC中在property处不再使用retain,而是使用strong，在dealloc中不需要再[super dealloc]。
@property（nonatomic,strong）Dog *dog;// 意味着生成的成员变量_dog是一个强指针，相当于以前的retain。

如果换成是弱指针，则换成weak，不需要加 ____ 。

8.3 ARC的特点总结

不允许调用release，retain，retainCount
允许重写dealloc,但是不允许调用[super dealloc]
@property的参数：
Strong:相当于原来的retain（适用于OC对象类型），成员变量是强指针
Weak:相当于原来的assign,(适用于oc对象类型)，成员变量是弱指针
Assign：适用于非OC对象类型（基础类型）

8.4 NSString的retainCount

** 提示：字符串是特殊的对象，但不需要使用release手动释放，这种字符串对象默认就是autorelease的，不用额外的去管内存，存放到堆中。 **

//1. 字符串常量
NSString *str1 = @"string";
NSLog(@"str1: %ld",[str1 retainCount]); // -1或18446744073709551615（即UINT_MAX ( Maximum value an `unsigned int')）

//因为"str"为字符串常量，系统不会收回，也不会对其作引用计数，即使我们对str如何retain或release。就是为-1.
 
//2. stringWithFormat
NSString *str2 = [NSString stringWithFormat:@"%s", "test"];
NSLog(@"str2:%ld",[str2 retainCount]); // 1
//使用stringWithFormat创建的NSString为变量，系统会进行引用计数。  以前为1，现在为-1.
 
//3. stringWithString
stringWithString这个方法比较特别：它的retainCount取决于它后面跟的string对象

NSString *str3 = [NSString stringWithString:@"test"];
NSString *str4 = [NSString stringWithString:[NSString stringWithFormat:@"test,%d  ,%d",1,3]];
NSLog(@"str3:%ld",[str3 retainCount]); // -1
NSLog(@"str4:%ld",[str4 retainCount]); // 2
//可以看到第一个为"常量"对象，其retainCount方法的实现返回的是maxIntValue。
//第二个为2，这个方法生成的只是一个对另一个对象的引用。一个对象实例，两次的stringWithString，它的retainCount为2，同时都被当前的AutoreleasePool管理。

8.5 补充

** 让程序兼容ARC和非ARC部分。转变为非ARC -fno-objc-arc 转变为ARC的， -f-objc-arc 。**
ARC也需要考虑循环引用问题：一端使用retain，另一端使用assign。

set  
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Person *p = [Person new];
        Car *car = [Car new];
        car.speed = 100;
        [p setCar:car];
        [p drive];
        
        [car release];
        
        /*
        //重复调用，已经释放了，要改加上if语句去进行判断
        [p setCar:car];
        [p drive];
        */
        
        Car *car2 = [Car new];
        car2.speed = 200;
        [p setCar:car2];
        
        
        [p drive];
        [car2 release];
        [p  release];


    }
    return 0;
}  

#import <Foundation/Foundation.h>
#import "Car.h"
@interface Person : NSObject
{
    Car *_car;
    NSString *_name;
}

- (void)setName:(NSString *)name;
- (NSString *)name;
- (void)setCar:(Car *)car;
- (Car *)car;
- (void)drive;
@end  

#import "Person.h"

@implementation Person
- (void)dealloc{
    //目的是要保证在p对象存在的时候，car对象一定存在
    //对象p被销毁的时候
    [_car release];
    [_name release];
    [super dealloc];
    NSLog(@"被释放了");
}

- (void)setName:(NSString *)name{
    if (_name != name) {
        [_name release];
        _name = [name retain];
    }

}
- (NSString *)name
{
    return _name;
}


- (void)setCar:(Car *)car{
    //第一次是空，所以release无所谓，第二次减一，要是不release的话，会造成内存泄露的问题。
    //car retainCount= 1
    if (_car != car) {
    [car release];
    }
   
    //car2 2
    _car = [car retain];//引用计数加1 ，返回self
}
- (void)drive{
    [_car run];
}
@end  

#import <Foundation/Foundation.h>

@interface Car : NSObject
@property int speed;

- (void)run;
@end  

#import "Car.h"

@implementation Car
- (void)dealloc{
    [super dealloc];
    NSLog(@"被释放了  %d",_speed);
}
- (void)run{
    NSLog(@"I can run");
}
@end

9. runtime 机制

9.1 run time 相关原理

对于runtime机制，在网上找到的资料大概就是怎么去用这些东西，以及查看runtime.h头文件中的实现，当然这确实是一种很好的学习方法，但是，其实我们还是不会知道runtime底层编译成C++语言之后做了什么？查到一个大牛给资料，顿时对runtime有了一定认识！

我们随便写一个小程序，代码如下： person类头文件如下，

<!-- lang: cpp -->
#import <Foundation/Foundation.h>

@interface Person : NSObject
@property (nonatomic, strong) NSString *name; 
@property (nonatomic, assign) int age;

@end

main.m文件如下
<!-- lang: cpp -->
int main(int argc, const char * argv[])

{
Person *p = [[Person alloc] init];
NSString *str = @"zhangsan";
p.name = str;
// p.name 等价于
[p setName:str];
p.age = 20;
return 0;

}

然后我们打开终端，在命令行找到cd到文件目录，然后中输入：
clang -rewrite-objc main.m

命令可以将main.m编译成C++的代码，改成不同的文件名，就会生成不同的c++代码这是就生成了main.cpp这个c++文件，打开文件代码查看该main.cpp最底下的main函数，这样我们就可以看到底层具体实现的方式！
这时，我们就需要知道这些方法：
**
objc_msgSend 可以给对象发送消息
objc_getClass(“Person”) 可以获取到指定名称的对象
sel_registerName(“alloc”) 可以调用到对象的方法
**

通过查看，c++代码，我们得出结论：
使用objc_msgSend函数，给objc_getClass函数实例化的对象发送sel_registerName获取到的方法这么一个消息代码是给人看的，顺带让机器实现功能。
日常的程序开发过程中，要少用runtime，
那什么时候会使用runtime呢？ runtime应用的时机：
1> 当需要非常高的性能开发时，使用runtime，注释：oc的代码已经无法满足性能需求
2> 当我们对系统内部的实现很好奇的时候，可以用clang反编译成c++去看底层的实现机制！

项目讲解的是runtime的底层实现原理，如果想要知道runtime是怎么用的，可以查看runtime.h头文件查看！以下是runtime机制方法的一些使用方法介绍，希望对大家有用！
相关技术文档：
http://www.tuicool.com/articles/uimInm http://blog.csdn.net/lengshengren/article/details/17764135

9.2runtime 的相关实现

首先，第一个问题，

runtime实现的机制是什么?

runtime是一套比较底层的纯C语言API, 属于1个C语言库, 包含了很多底层的C语言API。在我们平时编写的OC代码中, 程序运行过程时, 其实最终都是转成了runtime的C语言代码, runtime算是OC的幕后工作者比如说，下面一个创建对象的方法中，举例: OC :

 [[MJPerson alloc] init] 
runtime : 
objc_msgSend(objc_msgSend(“MJPerson” , “alloc”), “init”)

runtime 用来干什么呢？？用在那些地方呢？怎么用呢？

runtime是属于OC的底层, 可以进行一些非常底层的操作(用OC是无法现实的, 不好实现)

在程序运行过程中, 动态创建一个类(比如KVO的底层实现)
在程序运行过程中, 动态地为某个类添加属性\方法, 修改属性值\方法
遍历一个类的所有成员变量(属性)\所有方法

例如：我们需要对一个类的属性进行归档解档的时候属性特别的多，这时候，我们就会写很多对应的代码，但是如果使用了runtime就可以动态设置！

例如，PYPerson.h的文件如下所示

import

@interface PYPerson : NSObject 
@property (nonatomic, assign) int age; 
@property (nonatomic, assign) int height;
@property (nonatomic, copy) NSString *name; 
@property (nonatomic, assign) int age2; 
@property (nonatomic, assign) int height2; 
@property (nonatomic, assign) int age3; 
@property (nonatomic, assign) int height3; 
@property (nonatomic, assign) int age4; 
@property (nonatomic, assign) int height4;
@end

而PYPerson.m实现文件的内容如下


#import "PYPerson.h"

import
@implementation  PYPerson
- (void)encodeWithCoder:(NSCoder *)encoder {
 unsigned int count = 0; 
Ivar *ivars = class_copyIvarList([PYPerson class], &count);

for (int i = 0; i<count; i++) {

// 取出i位置对应的成员变量Ivar ivar = ivars[i];
// 查看成员变量const char *name = ivar_getName(ivar);
// 归档NSString *key = [NSString stringWithUTF8String:name];
id value = [self valueForKey:key];
[encoder encodeObject:value forKey:key];
}
free(ivars); 
}

(id)initWithCoder:(NSCoder *)decoder { 
if (self = [super init]) {
unsigned int count = 0;
Ivar *ivars = class_copyIvarList([PYPerson class], &count);for (int i = 0; i<count; i++) { 
// 取出i位置对应的成员变量 Ivar ivar = ivars[i]; 
// 查看成员变量 const char *name = ivar_getName(ivar);
 // 归档 NSString *key = [NSString stringWithUTF8String:name]; id value = [decoder decodeObjectForKey:key]; 
// 设置到成员变量身上 [self setValue:value forKey:key];}free(ivars);

}
 return self; 
}

@end

这样我们可以看到归档和解档的案例其实是runtime写下的.

学习runtime机制首先要了解下面几个问题

相关的头文件和函数
利用头文件，我们可以查看到runtime中的各个方法！
相关应用
NSCoding(归档和解档, 利用runtime遍历模型对象的所有属性)
字典 –> 模型 (利用runtime遍历模型对象的所有属性, 根据属性名从字典中取出对应的值, 设置到模型的属性上)
KVO(利用runtime动态产生一个类)
用于封装框架(想怎么改就怎么改) 这就是我们runtime机制的只要运用方向
相关函数
objc_msgSend : 给对象发送消息
class_copyMethodList : 遍历某个类所有的方法
class_copyIvarList : 遍历某个类所有的成员变量
class_….. 这是我们学习runtime必须知道的函数！
必备常识 1> Ivar : 成员变量 2> Method : 成员方法从上面例子中我们看到我们定义的成员变量，如果要是动态创建方法，可以使用Method.