目录
- 1. load
1.1 load 方法的调用
1.2 场景分析
1.3 源码分析- 2. initialize
2.1 initialize 方法的调用
2.2 场景分析
2.3 源码分析- 3. load 和 initialize 的区别
- 4. 相关面试题
1. load
1.1 load 方法的调用
- ① 调用时刻:
+load
方法会在Runtime
加载类、分类时调用(不管有没有用到这些类,在程序运行起来的时候都会加载进内存,并调用+load
方法);
每个类、分类的+load
,在程序运行过程中只调用一次(除非开发者手动调用)。 - ② 调用方式:系统自动调用
+load
方式为直接通过函数地址调用,开发者手动调用+load
方式为消息机制objc_msgSend
函数调用。 - ③ 调用顺序:
先调用类的+load
,按照编译先后顺序调用(先编译,先调用),调用子类的+load
之前会先调用父类的+load
;
再调用分类的+load
,按照编译先后顺序调用(先编译,先调用)(注意:分类的其它方法是:后编译,优先调用)。
1.2 场景分析
Person 以及它的两个分类 Person (Test)、Person (Test2) 都实现了+test
和+load
两个方法,且 Person (Test2) 最后编译。调用 Person 的+test
,并打印 Person 元类对象中的类方法列表,查看打印结果。
// Person
#import <Foundation/Foundation.h>
@interface Person : NSObject
+ (void)test;
+ (void)load;
@end
#import "Person.h"
@implementation Person
- (void)test {
NSLog(@"person test");
}
+ (void)load {
NSLog(@"person +load");
}
@end
// Person (Test)
...
// Person (Test2)
...
#import "ViewController.h"
#import "Person.h"
#import <objc/runtime.h>
@implementation ViewController
void printAllMethodNamesOfClass(Class cls)
{
u_int count;
Method *methods = class_copyMethodList(cls, &count);
NSMutableString *methodNames = [NSMutableString string];
for (int i = 0; i < count ; i++)
{
Method method = methods[i];
NSString *methodName = NSStringFromSelector(method_getName(method));
[methodNames appendString:methodName];
[methodNames appendString:@", "];
}
free(methods);
NSLog(@"%@: %@",cls,methodNames);
}
- (void)viewDidLoad {
[super viewDidLoad];
[Person test];
// 打印 Person 元类对象中的类方法列表
printAllMethodNamesOfClass(object_getClass([Person class]));
}
@end
/*
2020-02-18 22:05:33.114202+0800 Category [32631:7237868] person +load
2020-02-18 22:05:33.114929+0800 Category [32631:7237868] Person (Test) +load
2020-02-18 22:05:33.115009+0800 Category [32631:7237868] Person (Test2) +load
2020-02-18 22:05:33.209976+0800 Category [32631:7237868] Person (Test2) test
2020-02-18 22:05:33.210124+0800 Category [32631:7237868] Person: load, test, load, test, load, test,
*/
以上打印结果可以验证 Category 的几个原理:
- ① 分类方法会“覆盖”同名的宿主类方法,不是真正的覆盖,只是顺序超前了,通过
Runtime API
打印方法可以得知。 - ② 同名分类方法谁能生效取决于编译顺序,最后参与编译的分类中的同名方法会最终生效。
那么,为什么分类也实现了+load
方法,却不是只调用 Person (Test2) 的+load
,而是全部调用呢?下面我们进入源码分析。
1.3 源码分析
函数调用栈:
- objc-os.mm
① _objc_init:Runtime
的入口函数,进行一些初始化操作 - objc-runtime-new.mm
② load_images
③ prepare_load_methods
schedule_class_load
add_class_to_loadable_list
add_category_to_loadable_list
④ call_load_methods
call_class_loads
call_category_loads
(*load_method)(cls, SEL_load) 核心函数
load_images
void load_images(const char *path __unused, const struct mach_header *mh)
{
recursive_mutex_locker_t lock(loadMethodLock);
// Discover +load methods
prepare_load_methods((const headerType *)mh);
// Call +load methods (without classLock - re-entrant)
call_load_methods();
}
call_load_methods
先调用类的+load
方法,再调用分类的+load
方法。
void call_load_methods(void)
{
static bool loading = NO;
bool more_categories;
loadMethodLock.assertLocked();
// Re-entrant calls do nothing; the outermost call will finish the job.
if (loading) return;
loading = YES;
void *pool = objc_autoreleasePoolPush();
do {
// 1. Repeatedly call class +loads until there aren't any more
// ⚠️先调用类的 +load 方法
while (loadable_classes_used > 0) {
call_class_loads();
}
// 2. Call category +loads ONCE
// ⚠️再调用分类的 +load 方法
more_categories = call_category_loads();
// 3. Run more +loads if there are classes OR more untried categories
} while (loadable_classes_used > 0 || more_categories);
objc_autoreleasePoolPop(pool);
loading = NO;
}
call_class_loads & call_category_loads
类和分类的+load
方法是直接通过函数地址调用,所以都会调用。而其他方法如+test
则是通过消息机制objc_msgSend
函数调用,会优先查找宿主类中靠前的元素,找到同名方法就进行调用,所以优先调用最后编译的分类的方法。
typedef void(*load_method_t)(id, SEL); //函数指针
struct loadable_class {
Class cls; // may be nil
IMP method; // 类的 +load 方法的地址
};
struct loadable_category {
Category cat; // may be nil
IMP method; // 分类的 +load 方法的地址
};
static void call_class_loads(void)
{
int i;
// Detach current loadable list.
// ⚠️一堆可加载的类,将它们保存到存放 loadable_class 结构体类型元素的数组
struct loadable_class *classes = loadable_classes;
int used = loadable_classes_used;
loadable_classes = nil;
loadable_classes_allocated = 0;
loadable_classes_used = 0;
// Call all +loads for the detached list.
for (i = 0; i < used; i++) {
Class cls = classes[i].cls;
// ⚠️从数组中取出一个类的 method,这个 method 就是类的 +load 方法的地址
load_method_t load_method = (load_method_t)classes[i].method;
if (!cls) continue;
if (PrintLoading) {
_objc_inform("LOAD: +[%s load]\n", cls->nameForLogging());
}
// ⚠️直接通过函数地址调用 +load 方法
(*load_method)(cls, SEL_load);
}
// Destroy the detached list.
if (classes) free(classes);
}
static bool call_category_loads(void)
{
int i, shift;
bool new_categories_added = NO;
// Detach current loadable list.
// ⚠️一堆可加载的分类,将它们保存到存放 loadable_category 结构体类型元素的数组
struct loadable_category *cats = loadable_categories;
int used = loadable_categories_used;
int allocated = loadable_categories_allocated;
loadable_categories = nil;
loadable_categories_allocated = 0;
loadable_categories_used = 0;
// Call all +loads for the detached list.
for (i = 0; i < used; i++) {
Category cat = cats[i].cat;
// ⚠️从数组中取出一个分类的 method,这个 method 就是分类的 +load 方法的地址
load_method_t load_method = (load_method_t)cats[i].method;
Class cls;
if (!cat) continue;
cls = _category_getClass(cat);
if (cls && cls->isLoadable()) {
if (PrintLoading) {
_objc_inform("LOAD: +[%s(%s) load]\n",
cls->nameForLogging(),
_category_getName(cat));
}
// ⚠️直接通过函数地址调用 +load 方法
(*load_method)(cls, SEL_load);
cats[i].cat = nil;
}
}
......
}
从call_load_methods
函数中我们可以得知:先调用类的+load
方法,再调用分类的+load
方法。
那么在类或者分类中+load
方法的调用顺序是怎么样的呢?
从call_class_loads
和call_category_loads
函数中可以得知:可加载的类和分类分别保存在loadable_classes
和loadable_categories
数组中,因此我们只需要搞明白这两个数组中的类和分类的存放顺序,就可以知道调用顺序。
prepare_load_methods
按编译顺序将可加载的类添加进loadable_classes
数组,先添加父类,再添加子类;按编译顺序将可加载的分类添加进loadable_categories
数组。所以:
- 按编译顺序调用类的
+load
方法,先编译先调用,调用子类的+load
之前会先调用父类的+load
; - 按编译顺序调用分类的
+load
方法,先编译先调用。
void prepare_load_methods(const headerType *mhdr)
{
size_t count, i;
runtimeLock.assertLocked();
// 按编译顺序取得类数组
classref_t *classlist =
_getObjc2NonlazyClassList(mhdr, &count);
for (i = 0; i < count; i++) {
// 将可加载的类添加到 loadable_classes 数组中
// 先添加父类,再添加子类
schedule_class_load(remapClass(classlist[i]));
}
// 按编译顺序取得分类数组
category_t **categorylist = _getObjc2NonlazyCategoryList(mhdr, &count);
for (i = 0; i < count; i++) {
category_t *cat = categorylist[i];
Class cls = remapClass(cat->cls);
if (!cls) continue; // category for ignored weak-linked class
if (cls->isSwiftStable()) {
_objc_fatal("Swift class extensions and categories on Swift "
"classes are not allowed to have +load methods");
}
realizeClassWithoutSwift(cls);
assert(cls->ISA()->isRealized());
// 将可加载的分类添加到 loadable_categories 数组中
add_category_to_loadable_list(cat);
}
}
static void schedule_class_load(Class cls)
{
if (!cls) return;
assert(cls->isRealized()); // _read_images should realize
if (cls->data()->flags & RW_LOADED) return;
// Ensure superclass-first ordering
/* 递归调用
先添加父类,再添加子类
*/
schedule_class_load(cls->superclass);
// 将可加载的类添加到 loadable_classes 数组中
add_class_to_loadable_list(cls);
cls->setInfo(RW_LOADED);
}
2. initialize
2.1 initialize 方法的调用
- ① 调用时刻:
+initialize
方法会在类
第一次接收到消息时调用。
如果子类没有实现+initialize
方法,会调用父类的+initialize
,所以父类的+initialize
方法可能会被调用多次,但不代表父类初始化多次,每个类只会初始化一次。 - ② 调用方式:消息机制
objc_msgSend
函数调用。 - ③ 调用顺序:
先调用父类的+initialize
,再调用子类的+initialize
(先初识化父类,再初始化子类)
2.2 场景分析
Person 、Person 的两个分类 Person (Test)、Person (Test2) 以及它的子类 Student 都实现了+initialize
方法,且 Person (Test2) 最后编译。给 Student 类发送一条消息,查看打印结果。
// Person
#import "Person.h"
@implementation Person
+ (void)initialize {
NSLog(@"person +initialize");
}
@end
// Person (Test)
...
// Person (Test2)
...
// Student
...
#import "ViewController.h"
#import "Student.h"
- (void)viewDidLoad {
[super viewDidLoad];
[Student alloc];
}
/*
2020-02-19 20:48:59.230852+0800 Category [34163:7694237] Person (Test2) +initialize
2020-02-19 20:48:59.231052+0800 Category [34163:7694237] Student +initialize
*/
从以上打印结果可以得出结论:
- ①
+initialize
方法会在类
第一次接收到消息时调用; - ② 先调用父类的
+initialize
,再调用子类的+initialize
; - ③ 调用了分类的
+initialize
,没有调用宿主类的+initialize
。说明+initialize
方法的调用方式为消息机制,而非像+load
那样直接通过函数地址调用。
2.3 源码分析
OC 中的方法调用(也称消息发送),其实都是转换为objc_msgSend()
函数的调用。+initialize
方法会在类
第一次接收到消息时调用,说明在objc_msgSend()
函数内部会判断是不是第一次发送消息,是的话就调用+initialize
方法。
关于objc_msgSend()
函数的具体调用流程可以查看我的文章 深入浅出 Runtime(三):objc_msgSend方法调用流程。
下面我们通过Runtime
源码objc4-750
版本的来分析+initialize
方法的调用流程。(我查看了最新版本的+initialize
的函数调用栈与旧版本有差异,不过原理相同)
函数调用栈:
- objc-msg-arm64.s
① _objc_msgSend - objc-runtime-new.mm
② class_getInstanceMethod:调用方法之前需要先获取方法
③ lookUpImpOrNil
④ lookUpImpOrForward
⑤ _class_initialize:初始化类的函数
⑥ callInitialize
⑦ objc_msgSend(cls, SEL_initialize):给 cls 对象发送 initialize 消息
lookUpImpOrForward
IMP lookUpImpOrForward(Class cls, SEL sel, id inst,
bool initialize, bool cache, bool resolver)
{
......
// ⚠️如果 receiverClass 需要初始化且还未初始化,就进行初始化操作
// 调用 _class_initialize(cls),该函数中会递归遍历父类,判断父类是否存在且还未初始化 _class_initialize(cls->superclass)
// 调用 callInitialize(cls) ,给 cls 发送一条 initialize 消息((void(*)(Class, SEL))objc_msgSend)(cls, SEL_initialize)
// 所以 +initialize 方法会在类第一次接收到消息时调用
// 调用方式:objc_msgSend()
// 调用顺序:先调用父类的 +initialize,再调用子类的 +initialize (先初始化父类,再初始化子类,每个类只会初始化1次)
if (initialize && !cls->isInitialized()) {
runtimeLock.unlockRead();
_class_initialize (_class_getNonMetaClass(cls, inst));
runtimeLock.read();
// If sel == initialize, _class_initialize will send +initialize and
// then the messenger will send +initialize again after this
// procedure finishes. Of course, if this is not being called
// from the messenger then it won't happen. 2778172
}
......
}
_class_initialize
void _class_initialize(Class cls)
{
assert(!cls->isMetaClass());
Class supercls;
bool reallyInitialize = NO;
// Make sure super is done initializing BEFORE beginning to initialize cls.
// See note about deadlock above.
/* 递归调用
如果存在父类且父类未初始化,先初始化父类
*/
supercls = cls->superclass;
if (supercls && !supercls->isInitialized()) {
_class_initialize(supercls);
}
......
#if __OBJC2__
@try
#endif
{
// 调用 callInitialize
callInitialize(cls);
......
}
callInitialize
调用objc_msgSend
函数,给 cls 对象发送 initialize 消息。
void callInitialize(Class cls)
{
((void(*)(Class, SEL))objc_msgSend)(cls, SEL_initialize);
asm("");
}
3. load 和 initialize 的区别
区别 | load | initialize |
---|---|---|
调用时刻 | 在Runtime 加载类、分类时调用(不管有没有用到这些类,在程序运行起来的时候都会加载进内存,并调用 +load 方法)。每个类、分类的 +load ,在程序运行过程中只调用一次(除非开发者手动调用)。 |
在类 第一次接收到消息时调用。如果子类没有实现 +initialize 方法,会调用父类的+initialize ,所以父类的+initialize 方法可能会被调用多次,但不代表父类初始化多次,每个类只会初始化一次。 |
调用方式 | ① 系统自动调用+load 方式为直接通过函数地址调用;② 开发者手动调用 +load 方式为消息机制objc_msgSend 函数调用。 |
消息机制objc_msgSend 函数调用。 |
调用顺序 | ① 先调用类的+load ,按照编译先后顺序调用(先编译,先调用),调用子类的+load 之前会先调用父类的+load ;② 再调用分类的 +load ,按照编译先后顺序调用(先编译,先调用)(注意:分类的其它方法是:后编译,优先调用)。 |
① 先调用父类的+initialize ,② 再调用子类的 +initialize (先初识化父类,再初始化子类)。 |
4. 相关面试题
Q:Category 中有 +load 方法吗?+load 方法是什么时候调用的?+load 方法能继承吗?
- 分类中有
+load
方法; -
+load
方法在Runtime
加载类、分类的时候调用; -
+load
方法可以继承,但是一般情况下不会手动去调用+load
方法,都是让系统自动调用。
Q:手动调用 Student 类的 +load 方法,但是 Student 类没有实现该方法,为什么会去调用父类的 +load 方法,且是调用父类的分类的 +load 方法呢?
因为+load
方法可以继承,[Student load]
手动调用方式为是消息机制objc_msgSend
函数的调用,会去类方法列表里找对应的方法,由于 Student 类没有实现,就会去父类的方法列表中查找,且优先调用分类的+load
方法。而系统自动调用的+load
方法是直接通过函数地址调用的。
网友评论