/***********************************************************************
* call_load_methods
* Call all pending class and category +load methods.
调用所有的处理中的class和category的+load方法；
* Class +load methods are called superclass-first.
class的+load方法会被先调用，并且，一个调用一个class的+load方法前，会先对其父类的+load进行调用
* Category +load methods are not called until after the parent class's +load.
category的+load方法的调用，会发生在所有的class的+load方法完成调用之后。
*
* This method must be RE-ENTRANT, because a +load could trigger
* more image mapping. In addition, the superclass-first ordering
* must be preserved in the face of re-entrant calls. Therefore,
* only the OUTERMOST call of this function will do anything, and
* that call will handle all loadable classes, even those generated
* while it was running.
*
* The sequence below preserves +load ordering in the face of
* image loading during a +load, and make sure that no
* +load method is forgotten because it was added during
* a +load call.
* Sequence:调用顺序
* 1. Repeatedly call class +loads until there aren't any more
遍历所有的class对象，调用它们的+load方法，知道所有class中的+load都完成了调用
* 2. Call category +loads ONCE.
调用所有category中的+load方法
* 3. Run more +loads if:
这里我还不太理解，感觉上面都已经把所有的+load调用完了，还不太理解哪里会产生新的+load方法。有待继续补充......
* (a) there are more classes to load, OR
* (b) there are some potential category +loads that have
* still never been attempted.
* Category +loads are only run once to ensure "parent class first"
* ordering, even if a category +load triggers a new loadable class
* and a new loadable category attached to that class.
*
* Locking: loadMethodLock must be held by the caller
* All other locks must not be held.
**********************************************************************/
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
while (loadable_classes_used > 0) {
call_class_loads();
}
// 2. Call category +loads ONCE
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 all pending class +load methods.
* If new classes become loadable, +load is NOT called for them.
*
* Called only by call_load_methods().
**********************************************************************/
static void call_class_loads(void)
{
int i;
// Detach current loadable list.
struct loadable_class *classes = loadable_classes;//首先用局部变量loadable_class保存loadable_classes列表
int used = loadable_classes_used;//在用局部变量used保存loadable_classes_used
loadable_classes = nil;//将loadable_classes置空
loadable_classes_allocated = 0;//将loadable_classes_allocated清零
loadable_classes_used = 0;//将loadable_classes_used清零
// Call all +loads for the detached list.
for (i = 0; i < used; i++) {//遍历classes列表
Class cls = classes[i].cls;//从列表成员里面获得cls
load_method_t load_method = (load_method_t)classes[i].method;//从列表成员获取对应cls的+load 的IMP（方法实现）
if (!cls) continue;
if (PrintLoading) {
_objc_inform("LOAD: +[%s load]\n", cls->nameForLogging());
}
(*load_method)(cls, SEL_load);//这里就是对+load方法的调用，注意哦，这是直接的函数调用，不是消息机制那种哦，这里跟类的方法列表什么没关系，直接就是通过+load的IMP进行调用了
}
// Destroy the detached list.
if (classes) free(classes);
}
上面实现的主要逻辑发生在for循环里面，该for循环遍历了一个叫
classes
的列表，该列表存储的是一堆
loadable_class
结构体，
loadable_class
的定义如下
struct loadable_class {
Class cls; // may be nil
IMP method;
};
每一个
struct loadable_class
变量，存储的应该就是
一个类对象
+
一个与该类相关的方法实现
。从
loadable_class
这个命名，说明它内部的信息肯定是表示一个可以被加载的类的相关信息，因此合理推断，它里面的
method
应该就是类的
+load
方法，
cls
就是这个
+load
方法所对应的类对象。这个推断是否正确，我们一会讨论。
我们再看看源码中对于
classes
这个数组进行遍历时到底做了什么。很简单，就是通过函数指针
load_method
从
loadable_class
中获得
+load
方法的
IMP
作为其参数，然后就直接对其进行调用
(*load_method)(cls, SEL_load);
，所以，类对象的
+load
方法的调用实际上就发生在这里。这里的for循环一旦结束，
classes
所包含的所有类对象的
+load
方法就会被依次调用，这跟一个类是否被在工程项目里被实例化过，是否接受过消息，没有半毛钱关系。
至此，Runtime对于
+load
方法是如何调用的问题我们分析了一半，弄清楚了类对象的
+load
方法的是怎么被一个一个调用的，也就是
static void call_class_loads(void)
这个函数，接下来，还有问题的另一半–
static bool call_category_loads(void)
，也就是关于分类的
+load
方法的调用。进入其中
static bool call_category_loads(void)
{
int i, shift;
bool new_categories_added = NO;
// Detach current loadable list.
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;
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_method)(cls, SEL_load);
cats[i].cat = nil;
}
}
// Compact detached list (order-preserving)
shift = 0;
for (i = 0; i < used; i++) {
if (cats[i].cat) {
cats[i-shift] = cats[i];
} else {
shift++;
}
}
used -= shift;
// Copy any new +load candidates from the new list to the detached list.
new_categories_added = (loadable_categories_used > 0);
for (i = 0; i < loadable_categories_used; i++) {
if (used == allocated) {
allocated = allocated*2 + 16;
cats = (struct loadable_category *)
realloc(cats, allocated *
sizeof(struct loadable_category));
}
cats[used++] = loadable_categories[i];
}
// Destroy the new list.
if (loadable_categories) free(loadable_categories);
// Reattach the (now augmented) detached list.
// But if there's nothing left to load, destroy the list.
if (used) {
loadable_categories = cats;
loadable_categories_used = used;
loadable_categories_allocated = allocated;
} else {
if (cats) free(cats);
loadable_categories = nil;
loadable_categories_used = 0;
loadable_categories_allocated = 0;
}
if (PrintLoading) {
if (loadable_categories_used != 0) {
_objc_inform("LOAD: %d categories still waiting for +load\n",
loadable_categories_used);
}
}
return new_categories_added;
}
我们可以看到，这个方法的实现里面，通过系统注释，被划分如下几块：
A –
// Detach current loadable list
.分离可加载
category
列表，也就是把可加载列表的信息保存到本函数的局部变量cats数组上。
B –
// Call all +loads for the detached list
.消费
cats
里面的所有
+load
方法（也就是调用它们）
C –
// Compact detached list (order-preserving)
清理
cats
里面已经被消费过的成员，并且更新
used
计数值
D –
// Copy any new +load candidates from the new list to the detached list.
如果又出现了新的可加载的分类，将其相关内容复制到
cats
列表上。
E –
// Destroy the new list.
销毁列表（这里指的是外部的
loadable_categories
变量）
F –
// Reattach the (now augmented) detached list. But if there's nothing left to load, destroy the list.
更新几个记录了category+load信息的几个全局变量。
相比较于
call_class_loads
方法，这里多了步骤C、D、F。关于A、B、E这三个步骤，因为跟
call_class_loads
方法里面实现是一样的，不作重复解释。且看看多出来的这几步
先看C
Objective-C的+load方法调用原理分析
对于这个，我画个图演示一下，就明白了
Objective-C的+load方法调用原理分析
其实我感觉消费完一轮+load方法之后，cats里面基本上会在这个步骤被清空。
然后我们看看D步骤，如下图
Objective-C的+load方法调用原理分析
其实主要任务就是把新的可以加载的分类（
category
）信息（如果此时发现还有的话）添加到本函数的
cats
数组上。
最后看看F步骤
Objective-C的+load方法调用原理分析
小结B –
Runtime
对于
+load
方法的调用，不是走的我们熟悉的“消息发送”路线，而是直接拿到
+load
方法的
IMP
，直接调用。因此不存在所谓“类的方法被
category
的方法覆盖”的问题，所以除了
结论A
的 类与分类的
+load
方法先后调用顺序外，我们看到类与它的分类的所有的
+load
全部都被调用了，没有被覆盖。
目前，我们确定了类对象的
+load
方法会先于分类的
+load
方法被调用，并且不存在覆盖现象。
那么对于类于类之间
+load
调用顺序是怎样的？
同样的疑问对于分类(
category
)又是如何呢？
这两个问题，我们就需要进入
prepare_load_methods
方法的实现，看看
+load
方法被调用前，Runtime是如何准备它们的。
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++) {
/** ✈️✈️✈️✈️✈️
定制/规划类的加载
*/
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
realizeClass(cls);
assert(cls->ISA()->isRealized());
add_category_to_loadable_list(cat);
}
}
/***********************************************************************
* prepare_load_methods
* Schedule +load for classes in this image, any un-+load-ed
* superclasses in other images, and any categories in this image.
**********************************************************************/
// Recursively schedule +load for cls and any un-+load-ed superclasses.
// cls must already be connected.
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);
/** <#注释标题#>✈️✈️✈️✈️✈️
将cls添加到loadable_classes数组的最后面
*/
add_class_to_loadable_list(cls);
cls->setInfo(RW_LOADED);
}
