這個問題有點(diǎn)炒冷飯了膏斤，寫了 demo 才更深入的了解這個問題盅惜，就當(dāng)做個簡單的筆記吧
一. Load和Initialize的往死了問是一種怎樣的體驗吸耿？
- Load 和 Initialize 先加載哪個？
- 父類和子類以及 Category 的關(guān)系酷窥？
- 如果是多個 Category 呢咽安？
Load
開發(fā)文檔的直接解讀
加載順序總結(jié)
- 所有類和分類的 +load 方法都是在被加入到 runtime 的時候調(diào)用
- 父類優(yōu)先于子類加載（內(nèi)部通過遞歸的的方式實現(xiàn)）
- 在所有本類加載完畢之后再去加載各個分類
- 同一個類的多個分類加載順序可查看 Target -> Build Phases -> Compile Sources
比如，現(xiàn)有Student 繼承于 Person蓬推，Student擁有多個分類妆棒，在各個類的 + load 方法進(jìn)行打印，結(jié)果如下
2017-06-26 18:30:59.857400+0800 load[70593:5621604] Person ==> Load
2017-06-26 18:30:59.857596+0800 load[70593:5621604] Student ==> Load
2017-06-26 18:30:59.857656+0800 load[70593:5621604] Test2 ==> Load
2017-06-26 18:30:59.857707+0800 load[70593:5621604] Test1 ==> Load
2017-06-26 18:30:59.857724+0800 load[70593:5621604] Student + load2 ==> Load
2017-06-26 18:30:59.857730+0800 load[70593:5621604] Student + load3 ==> Load
2017-06-26 18:30:59.857736+0800 load[70593:5621604] Student + load1 ==> Load
查看 Compile Sources沸伏，觀察 Student 三個分類的加載順序糕珊，與 load 調(diào)用順序一致
runtime 源碼閱讀
首先看下 objc-runtime-new.mm 中的 void prepare_load_methods(header_info *hi) 函數(shù)，在該函數(shù)中準(zhǔn)備好 類和分類執(zhí)行 +load 方法的必要條件毅糟，以供接下來的調(diào)用
void prepare_load_methods(header_info *hi)
{
size_t count, i;
rwlock_assert_writing(&runtimeLock);
classref_t *classlist =
_getObjc2NonlazyClassList(hi, &count);
for (i = 0; i < count; i++) {
schedule_class_load(remapClass(classlist[i]));
}
category_t **categorylist = _getObjc2NonlazyCategoryList(hi, &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);
}
}
同時红选，在處理類的時候，也調(diào)用了同文件中的另外一個函數(shù) static void schedule_class_load(Class cls)
static void schedule_class_load(Class cls)
{
if (!cls) return;
assert(cls->isRealized()); // _read_images should realize
if (cls->data()->flags & RW_LOADED) return;
# warning 此處使用遞歸的思想實現(xiàn)了先調(diào)用父類再調(diào)用子類的 +load 方法
// Ensure superclass-first ordering
schedule_class_load(cls->superclass);
add_class_to_loadable_list(cls);
cls->setInfo(RW_LOADED);
}
當(dāng)前所有滿足 +load 方法調(diào)用條件的類和分類就被分別存放在全局變量 loadable_classes （load_images 方法調(diào)用）和 loadable_categories 中了
準(zhǔn)備好類和分類后姆另，接下來就是對它們的 +load 方法進(jìn)行調(diào)用了喇肋。打開文件 objc-loadmethod.m 坟乾，找到其中的 void call_load_methods(void) 函數(shù)。
void call_load_methods(void)
{
static BOOL loading = NO;
BOOL more_categories;
recursive_mutex_assert_locked(&loadMethodLock);
// 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;
}
同樣的蝶防，這個函數(shù)的作用就是調(diào)用上一步準(zhǔn)備好的類和分類中的 +load 方法甚侣，并且確保類優(yōu)先于分類的順序间学。我們繼續(xù)查看在這個函數(shù)中調(diào)用的另外兩個關(guān)鍵函數(shù) static void call_class_loads(void) 和 static BOOL call_category_loads(void) 。下面就以 static void call_class_loads(void) 函數(shù)為例進(jìn)行探討
static void call_class_loads(void)
{
int i;
// Detach current loadable list.
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;
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_method)(cls, SEL_load);
}
// Destroy the detached list.
if (classes) _free_internal(classes);
}
這個函數(shù)的作用就是真正負(fù)責(zé)調(diào)用類的 +load 方法了详羡。它從全局變量 loadable_classes 中取出所有可供調(diào)用的類，并進(jìn)行清零操作嘿悬。
// 指向 用于保存類信息的內(nèi)存的首地址
loadable_classes = nil;
// 標(biāo)識已分配的內(nèi)存空間大小
loadable_classes_allocated = 0;
// 標(biāo)識已使用的內(nèi)存空間大小
loadable_classes_used = 0;
load_images -> load_images_nolock -> prepare_load_methods -> schedule_class_load -> add_class_to_loadable_list 的時候會將未加載的類添加到 loadable_classes
調(diào)用類和分類的 +load 方法是直接使用函數(shù)內(nèi)存地址的方式 (*load_method)(cls, SEL_load); 殷绍，而不是使用發(fā)送消息 objc_msgSend 的方式鹊漠。因此load方法無繼承關(guān)系茶行，比如子類沒有實現(xiàn)+load方法躯概，加載子類的時候是不會調(diào)用父類的+load方法的；同理一個類和其分類的+load方法都會被調(diào)用
調(diào)用 load 方法之前畔师，所有的 framework 都已經(jīng)加載到了運(yùn)行時中娶靡，所以調(diào)用 framework 中的方法都是安全的
Initialize
首先看一下蘋果官方文檔對 Initialize 的定義
打開 objc-runtime-new.mm看锉，找到以下函數(shù)
// 當(dāng)我們給某個類發(fā)送消息的時候，runtime會調(diào)用這個函數(shù)在類中查找相應(yīng)方法的實現(xiàn)或轉(zhuǎn)發(fā)
#warning 考慮以上特性呻此，說明該類接收到第一條消息之前才會調(diào)用 +initialize 方法
IMP lookUpImpOrForward(Class cls, SEL sel, id inst,
bool initialize, bool cache, bool resolver)
{
...
rwlock_unlock_write(&runtimeLock);
}
# warning 注：當(dāng)類沒有初始化時腔寡， runtime 會調(diào)用 void _class_initialize(Class cls) 函數(shù)對該類進(jìn)行初始化
if (initialize && !cls->isInitialized()) {
_class_initialize (_class_getNonMetaClass(cls, inst));
// 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
}
// The lock is held to make method-lookup + cache-fill atomic
// with respect to method addition. Otherwise, a category could
...
}
接下來看看具體的初始化代碼
void _class_initialize(Class cls)
{
...
Class supercls;
BOOL reallyInitialize = NO;
#warning 同樣使用遞歸的思想實現(xiàn)了先調(diào)用父類再調(diào)用子類的順序
// 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);
}
// Try to atomically set CLS_INITIALIZING.
monitor_enter(&classInitLock);
if (!cls->isInitialized() && !cls->isInitializing()) {
cls->setInitializing();
reallyInitialize = YES;
}
monitor_exit(&classInitLock);
if (reallyInitialize) {
// We successfully set the CLS_INITIALIZING bit. Initialize the class.
// Record that we're initializing this class so we can message it.
_setThisThreadIsInitializingClass(cls);
// Send the +initialize message.
// Note that +initialize is sent to the superclass (again) if
// this class doesn't implement +initialize. 2157218
if (PrintInitializing) {
_objc_inform("INITIALIZE: calling +[%s initialize]",
cls->nameForLogging());
}
#warning 注意這里使用了 objc_msgSend放前，就意味著該方法就和其他普通方法一樣，子類要沿用父類的方法凭语，分類會會覆蓋本類中的方法。
#warning 同時吨些，如果子類沒有實現(xiàn)但父類實現(xiàn)了該方法，那么父類的該方法就要被實現(xiàn)多次
((void(*)(Class, SEL))objc_msgSend)(cls, SEL_initialize);
if (PrintInitializing) {
_objc_inform("INITIALIZE: finished +[%s initialize]",
...
}
- 針對 Category挽拔，經(jīng)測試發(fā)現(xiàn)：Category 中 Initialize 方法會覆蓋其本類中的方法(和其他普通方法效果一樣)
- 在 Initialize 方法內(nèi)部可以進(jìn)行一些不方便在編譯期進(jìn)行初始化的靜態(tài)變量的賦值
#warning Person.m
// int 等基本類型可以在編譯期進(jìn)行賦值
static int numCount = 0;
// 對象無法在編譯器進(jìn)行賦值
static NSMutableArray *dataSource;
+ (void)initialize {
if (self == [Person class]) {
// 不能在編譯期賦值的對象在這里進(jìn)行賦值
dataSource = [[NSMutableArray alloc] init];
}
}
異常情況：在A類的load 方法中調(diào)用了B類的類方法
@implementation Father
+ (void)load {
NSLog(@"father==> load===%@", [Dog class]);
}
+(void)initialize {
NSLog(@"Father===>initialize");
}
@end
#warning 打印結(jié)果如下
2017-08-09 11:19:09.838 tests[34274:8415363] Dog===>initialize
2017-08-09 11:19:09.839 tests[34274:8415363] father==> load===Dog
2017-08-09 11:19:09.839 tests[34274:8415363] Dog==> load
2017-08-09 11:19:09.840 tests[34274:8415363] child==> load
2017-08-09 11:19:09.840 tests[34274:8415363] child + hahha==> load
2017-08-09 11:19:09.840 tests[34274:8415363] main
以下是Compile Source 截圖
總結(jié)
- 正常情況下(即沒有在 load 方法中調(diào)用相關(guān)類方法)螃诅，load 和 Initialize 方法都在實例化對象之前調(diào)用状囱，load相當(dāng)于裝載方法，都在main()函數(shù)之前調(diào)用亭枷，Initialize方法都在main() 函數(shù)之后調(diào)用。
- 如果在A類的 load 方法中調(diào)用 B 類的類方法猾编，那么在調(diào)用A的Load 方法之前升敲，會先調(diào)用一下B類的initialize 方法，但是B類的load 方法還是按照 Compile Source 順序進(jìn)行加載
- 所有類的 load 方法都會被調(diào)用瘪撇，先調(diào)用父類港庄、再調(diào)用子類，多個分類會按照Compile Sources 順序加載鹏氧。但是Initialize 方法會被覆蓋，子類父類分類中只會執(zhí)行一個
- load 方法內(nèi)部一般用來實現(xiàn) Method Swizzle歼捏，Initialize方法一般用來初始化全局變量或者靜態(tài)變量
- 兩個方法都不能主動調(diào)用笨篷，也不需要通過 super 繼承父類方法，但是 Initialize 方法會在子類沒有實現(xiàn)的時候調(diào)用父類的該方法率翅，而 load 不會
