【iOS】架构师之路~底层原理篇一 :(OC本质、KVC、KVO、Categroy、Block）

时间 2019-11-07

标签 iOS 架构师之路底层原理本质 kvc kvo categroy block 栏目 iOS 繁體版

原文原文链接

【iOS】架构师之路~底层原理二: (Runtime、Runloop)objective-c

一. OC 对象本质

1.1 OC对象数据结构

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

因此 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;
复制代码

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种:
1. instance对象 (实例对象)
2. class对象 (类对象)
3. meta-class对象 (元类对象)
复制代码

2.1 instance对象 (实例对象)

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

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

object一、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.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)
复制代码

元类对象内存布局:app

三. isa指针 & superclass指针

3.1 isa 指针

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

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

3.2 superClass 指针

class对象的superclass指针框架

当Student的instance对象要调用Person的对象方法时，会先经过isa找到Student的class，
而后经过superclass找到Person的class，最后找到对象方法的实现进行调用
复制代码

meta-class对象的superclass指针

当Student的class要调用Person的类方法时，会先经过isa找到Student的meta-class，
而后经过superclass找到Person的meta-class，最后找到类方法的实现进行调用
复制代码

3.3 isa 和 superClass 总结

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源码下载 opensource.apple.com/tarballs/ob…

五. KVO 原理及实现

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

使用了KVO监听的对象

- 利用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; 
复制代码

七. Categroy

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

- 经过Runtime加载某个类的全部Category数据

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

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

Category的底层结构

八. 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))
复制代码

关联对象的原理

十一. Block

###11.1 Block 本质

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

block的底层结构以下图所示

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

11.2 Block分类

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

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变量包装成一个对象

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）
![](https://user-gold-cdn.xitu.io/2019/8/23/16cbc949417acef8?w=1000&h=274&f=png&s=60780)
复制代码

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
复制代码

参考：iOS底层原理班（下）/OC对象/关联对象/多线程/内存管理/性能优化

【iOS】架构师之路~底层原理篇 一 :(OC本质、KVC、KVO、Categroy、Block）