[iOS]底层原理一 : (OC 本质、KVC、KVO、Cate

2019-10-10 本文已影响0人 iLees

底层原理一: (OC 本质、KVC、KVO、Category、Block)
底层原理二: (Runtime、Runloop)
底层原理三 : (多线程、内存管理)
底层原理四 : (性能优化、架构)
底层原理五 : (面试题目整理)

一. OC对象本质

1.1 OC对象数据结构

我们平时编写的Objective-C代码，底层实现其实都是C\C++代码

1.png

所以Objective-C的面向对象都是基于C\C++的数据结构实现的

将Objective-C代码转换为C\C++代码

xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc OC源文件 -o 输出的CPP文件
如果需要链接其他框架，使用-framework参数。比如-framework UIKit

OC对象的数据结构

// NSObject Implementation
struct NSObject_IMPL {
    Class isa; // 8个字节,Class也是一个结构体指针
    ... //成员变量
};

// Class指针
typedef struct objc_class *Class;

举例

@interface Student : NSObject
{
    @public
    int _no;
    int _age;
}
@end

@implementation Student
@end


实际转为C/C++代码为:
struct Student_IMPL {
    Class isa;
    int _no;
    int _age;
};

1.2 查看一个对象占用了多少内存

创建一个实例对象，至少需要多少内存？
#import <objc/runtime.h>
class_getInstanceSize([NSObject class]);

创建一个实例对象，实际上分配了多少内存？
#import <malloc/malloc.h>
malloc_size((__bridge const void *)obj);

1.3 常用的LLDB指令

print、p：打印
po：打印对象

读取内存
memory read/数量格式字节数  内存地址
x/数量格式字节数  内存地址
x/3xw  0x10010

修改内存中的值
memory  write  内存地址  数值
memory  write  0x0000010  10

bt 打印调用堆栈信息

call 调用方法

二. OC对象的分类

OC对象可以分为3种:

instance对象 (实例对象)
class对象 (类对象)
meta-class对象 (元类对象)

2.1 instance对象 (实例对象)

instance对象就是通过类alloc出来的对象，每次调用alloc都会产生新的instance对象

NSObject *object1 = [[NSObject alloc] init];
 NSObject *object2 = [[NSObject alloc] init];

object1、object2是NSObject的instance对象（实例对象）
它们是不同的两个对象，分别占据着两块不同的内存

instance对象在内存中存储的信息包括
    -isa指针
    -其他成员变量

2.2 Class对象 (类对象)

我们平时说的类,其实也是对象,称为类对象, 每个类在内存中有且只有一个class对象

NSObject *object1 = [[NSObject alloc] init];
NSObject *object2 = [[NSObject alloc] init];
Class objectClass1 = [object1 class];
Class objectClass2 = [object2 class];
Class objectClass3 = object_getClass(object1);
Class objectClass4 = object_getClass(object2);
Class objectClass5 = [NSObject class];

objectClass1 ~ objectClass5都是NSObject的class对象（类对象）

它们是同一个对象。每个类在内存中有且只有一个class对象

class对象在内存中存储的信息主要包括
isa指针
superclass指针
类的属性信息（@property）、类的对象方法信息（instance method）
类的协议信息（protocol）、类的成员变量信息（ivar）
......

一个类对象的内存布局

2.png

2.3 meta-Class 元类对象

每个类在内存中有且只有一个meta-class对象

// 将类对象当做参数传入，获得元类对象
Class objectMetaClass = object_getClass(objectClass5);

objectMetaClass是NSObject的meta-class对象（元类对象）

每个类在内存中有且只有一个meta-class对象

meta-class对象和class对象的内存结构是一样的，但是用途不一样，在内存中存储的信息主要包括
isa指针
superclass指针
类的类方法信息（class method）
......

查看是否为元类对象: 
Bool result = class_isMetaClass(objectMetaClass)

元类对象内存布局

3.png

三. isa指针 & superclass指针

3.1 isa 指针

4.png

instance的isa指向class
当调用对象方法时，通过instance的isa找到class，最后找到对象方法的实现进行调用

class的isa指向meta-class
当调用类方法时，通过class的isa找到meta-class，最后找到类方法的实现进行调用

3.2 superClass 指针

class对象的superclass指针

5.png

当Student的instance对象要调用Person的对象方法时，会先通过isa找到Student的class，
然后通过superclass找到Person的class，最后找到对象方法的实现进行调用

meta-class对象的superclass指针

6.png

当Student的class要调用Person的类方法时，会先通过isa找到Student的meta-class，
然后通过superclass找到Person的meta-class，最后找到类方法的实现进行调用

3.3 isa 和 superClass 总结

7.png

instance的isa指向class

class的isa指向meta-class

meta-class的isa指向基类的meta-class

class的superclass指向父类的class
-如果没有父类，superclass指针为nil

meta-class的superclass指向父类的meta-class
-基类的meta-class的superclass指向基类的class

instance调用对象方法的轨迹
-isa找到class，方法不存在，就通过superclass找父类

class调用类方法的轨迹
-isa找meta-class，方法不存在，就通过superclass找父类

四.窥探struct objc_class的结构

objc4源码地址( https://opensource.apple.com/tarballs/objc4/)

8.png

9.png

五. KVO 原理及实现

KVO的全称是Key-Value Observing，俗称“键值监听”，可以用于监听某个对象属性值的改变

10.png

使用了KVO监听的对象

11.png

- 利用RuntimeAPI动态生成一个子类，并且让instance对象的isa指向这个全新的子类
- 当修改instance对象的属性时，会调用Foundation的_NSSetXXXValueAndNotify函数
        willChangeValueForKey:
        父类原来的setter
        didChangeValueForKey:
    - 内部会触发监听器（Oberser）的监听方法(observeValueForKeyPath:ofObject:change:context:）

// 代码

- (void)viewDidLoad {
    [super viewDidLoad];
    
    Person *person = [[Person alloc]init];;
    [p addObserver:self forKeyPath:@"name" options:NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld context:nil];    
}

- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSKeyValueChangeKey,id> *)change context:(void *)context{
   NSLog(@"被观测对象：%@, 被观测的属性：%@, 值的改变: %@\n, 携带信息:%@", object, keyPath, change, context);
}

六. KVC 原理及实现

KVC的全称是Key-Value Coding，俗称“键值编码”，可以通过一个key来访问某个属性

常见的API有
- (void)setValue:(id)value forKeyPath:(NSString *)keyPath;
- (void)setValue:(id)value forKey:(NSString *)key;
- (id)valueForKeyPath:(NSString *)keyPath;
- (id)valueForKey:(NSString *)key;

setValue:forKey:的原理

12.png

七. Categroy

Categroy 给类扩展方法,或者关联属性, Categroy底层结构也是一个结构体:
内部存储这结构体的名字,那个类的分类,以及对象和类方法列表,协议,属性信息

- 通过Runtime加载某个类的所有Category数据

- 把所有Category的方法、属性、协议数据，合并到一个大数组中
  后面参与编译的Category数据，会在数组的前面

- 将合并后的分类数据（方法、属性、协议），插入到类原来数据的前面

Category的底层结构

13.png

八.Load

+load方法会在runtime加载类、分类时调用

每个类、分类的+load，在程序运行过程中只调用一次

调用顺序
1. 先调用类的+load   
    按照编译先后顺序调用（先编译，先调用）
    调用子类的+load之前会先调用父类的+load

2.再调用分类的+load
    按照编译先后顺序调用（先编译，先调用）

九.Initialze

+initialize方法会在类第一次接收到消息时调用

- 调用顺序
    先调用父类的+initialize，再调用子类的+initialize
    (先初始化父类，再初始化子类，每个类只会初始化1次)

- +initialize和+load的很大区别是，+initialize是通过objc_msgSend进行调用的，所以有以下特点
    如果子类没有实现+initialize，会调用父类的+initialize（所以父类的+initialize可能会被调用多次）
    如果分类实现了+initialize，就覆盖类本身的+initialize调用

十.Categroy 添加属性

默认情况下，因为分类底层结构的限制，不能添加成员变量到分类中。但可以通过关联对象来间接实现

关联对象提供了以下API
添加关联对象
void objc_setAssociatedObject(id object, const void * key,
                                id value, objc_AssociationPolicy policy)

获得关联对象
id objc_getAssociatedObject(id object, const void * key)

移除所有的关联对象
void objc_removeAssociatedObjects(id object)


key的常见用法

static void *MyKey = &MyKey;
objc_setAssociatedObject(obj, MyKey, value, OBJC_ASSOCIATION_RETAIN_NONATOMIC)
objc_getAssociatedObject(obj, MyKey)

static char MyKey;
objc_setAssociatedObject(obj, &MyKey, value, OBJC_ASSOCIATION_RETAIN_NONATOMIC)
objc_getAssociatedObject(obj, &MyKey)

使用属性名作为key
objc_setAssociatedObject(obj, @"property", value, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
objc_getAssociatedObject(obj, @"property");

使用get方法的@selecor作为key
objc_setAssociatedObject(obj, @selector(getter), value, OBJC_ASSOCIATION_RETAIN_NONATOMIC)
objc_getAssociatedObject(obj, @selector(getter))

关联对象的原理

14.png

15.png

十一.Block

11.1 Block 本质

block本质上也是一个OC对象，它内部也有个isa指针
block是封装了函数调用以及函数调用环境的OC对象

block的底层结构如下图所示

16.png

block的变量捕获（capture）
为了保证block内部能够正常访问外部的变量，block有个变量捕获机制

17.png

11.2 Block分类

block有3种类型，可以通过调用class方法或者isa指针查看具体类型，最终都是继承自NSBlock类型
__NSGlobalBlock__ （ _NSConcreteGlobalBlock ） 全局 block   没有访问auto变量
__NSStackBlock__ （ _NSConcreteStackBlock ）   栈 block     访问了auto变量
__NSMallocBlock__ （ _NSConcreteMallocBlock ） 堆 block     __NSStackBlock__调用了copy

18.png

11.3 Block copy

在ARC环境下，编译器会根据情况自动将栈上的block复制到堆上，比如以下情况
-block作为函数返回值时
-将block赋值给__strong指针时
-block作为Cocoa API中方法名含有usingBlock的方法参数时
-block作为GCD API的方法参数时

MRC下block属性的建议写法
-@property (copy, nonatomic) void (^block)(void);

ARC下block属性的建议写法
-@property (strong, nonatomic) void (^block)(void);
-@property (copy, nonatomic) void (^block)(void);

11.4 __Block修饰符

__block可以用于解决block内部无法修改auto变量值的问题
__block不能修饰全局变量、静态变量（static）

编译器会将__block变量包装成一个对象

19.png

11.5 __Block内存管理

当block在栈上时，并不会对__block变量产生强引用

当block被copy到堆时
会调用block内部的copy函数
copy函数内部会调用_Block_object_assign函数
_Block_object_assign函数会对__block变量形成强引用（retain）

当block从堆中移除时
会调用block内部的dispose函数
dispose函数内部会调用_Block_object_dispose函数
_Block_object_dispose函数会自动释放引用的__block变量（release）

20.png

11.6 Block 循环引用

arc    用__weak、__unsafe_unretained解决
 mrc   用__Block、__unsafe_unretained解决

11.7 __unsafe_unretained

unsafe / 不安全   unretained/不引用
也可以解决循环引用,但是 指向对象销魂,指针存储地址不变,所以不推荐使用.__weak 会自动将指针变量设置为 nil     .__Block也可以解决循环引用,需要手动将引用的对象设置 nil,手动解决循环引用

MRC 下通过 __unsafe_unretained解决 或者__block 解决 __Block 修饰以后,Block 内部不会对引用对象进行强引用,计数器不会+1