/***********************************************************************
* 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);
}
