阅读 454

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

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

一. 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对象

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

元类对象内存布局:

三. 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对象/关联对象/多线程/内存管理/性能优化

关注下面的标签,发现更多相似文章
评论