您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 程式開發 >> iOS 開發基礎

你真的了解 +load 方法嗎?從 runtime 源碼看它的呼叫時機

編輯:iOS 開發基礎

本文授權轉載,作者:左書祺(關注倉庫,及時獲得更新:iOS-Source-Code-Analyze)

由於 ObjC 的 runtime 只能在 Mac OS 下編譯,文中程式碼都在 x86_64 架構下執行;涉及 arm64 的差異會另外說明。

寫在前面

這個標題與其說是在問讀者,不如說是在問我自己:我真的了解 + load 嗎?

作為 Objective-C 裡的一個方法,+load 的特別之處在於:它只是檔案被載入 runtime 時、在 main 函數被呼叫之前,由 ObjC runtime 主動觸發的一個鉤子方法。三個關鍵詞:檔案剛載入、main 之前、鉤子方法。

讀源碼之前,我一直以為自己很懂它。看完實作之後才明白,以前的「以為」只是以為。

本文假設你已經寫過 +load,也大致知道它的呼叫順序(下面會簡單複習)。篇幅重點不在列舉它僅有的幾個用途,而在回答兩個問題:+load 是怎麼被呼叫的,以及它為什麼呈現那樣的順序。

從呼叫棧看起

先看一段最小程式碼:

#import <Foundation/Foundation.h>

@interface XXObject : NSObject
@end

@implementation XXObject
+ (void)load {
    NSLog(@"XXObject load");
}
@end

int main(int argc, const char *argv[]) {
    @autoreleasepool { }
    return 0;
}

main 函數裡什麼都沒呼叫,但執行後依然會印出 XXObject load:

用符號斷點抓呼叫鏈

在 Xcode 加一個符號斷點 +[XXObject load](注意 + 與 [ 之間沒有空格):

重新執行,程式會停在 NSLog 那一行,左側呼叫棧把答案攤開了我們面前:

0   +[XXObject load]
1   call_class_loads()
2   call_load_methods
3   load_images
4   dyld::notifySingle(dyld_image_states, ImageLoader const*)
11  _dyld_start

dyld 是 the dynamic link editor 的縮寫,也就是蘋果的動態連結器。系統內核完成程序的準備工作後,剩下的交給它接手(本文不展開)。

每當有新鏡像載入,都會回呼 load_images,而這個回呼是在 runtime 初始化時透過 _objc_init 註冊的:

dyld_register_image_state_change_handler(dyld_image_state_dependents_initialized, 0/*not batch*/, &load_images);

load_images 會收到最新鏡像的資訊列表 infoList:

const char *load_images(enum dyld_image_states state, uint32_t infoCount,
                        const struct dyld_image_info infoList[]) {
    bool found = false;
    for (uint32_t i = 0; i < infoCount; i++) {
        if (hasLoadMethods((const headerType *)infoList[i].imageLoadAddress)) {
            found = true;
            break;
        }
    }
    if (!found) return nil;

    recursive_mutex_locker_t lock(loadMethodLock);
    {
        rwlock_writer_t lock2(runtimeLock);
        found = load_images_nolock(state, infoCount, infoList);
    }
    if (found) {
        call_load_methods();
    }
    return nil;
}

鏡像是什麼

下個問題順勢而來:鏡像到底是什麼?下斷點印出來看看。

從輸出可以看出,鏡像並不是某個 Objective-C 原始檔,而是一個 target 的編譯產物:

(const dyld_image_info) $52 = {
    imageLoadAddress = 0x00007fff8a144000;
    imageFilePath    = "/System/Library/Frameworks/CoreServices.framework/Versions/A/CoreServices";
    imageFileModDate = 1452737802;
}
(const dyld_image_info) $53 = {
    imageLoadAddress = 0x00007fff946d9000;
    imageFilePath    = "/usr/lib/liblangid.dylib";
}
(const dyld_image_info) $54 = {
    imageLoadAddress = 0x00007fff88016000;
    imageFilePath    = "/System/Library/Frameworks/Foundation.framework/Versions/C/Foundation";
}
(const dyld_image_info) $55 = {
    imageLoadAddress = 0x0000000100000000;
    imageFilePath    = "/Users/apple/Library/Developer/Xcode/DerivedData/.../Build/Products/Debug/debug-objc";
    imageFileModDate = 0;
}

這裡面有大量動態連結庫,也有蘋果提供的框架,例如 Foundation、CoreServices,它們都是透過 load_images 載入的,而 imageFilePath 指向的都是二進位檔案。最後那條則指向一個可執行檔,直接執行它的結果與在 Xcode 裡跑一致。

呼叫前的準備

回到 load_images。掃描鏡像時若發現 +load 符號:

for (uint32_t i = 0; i < infoCount; i++) {
    if (hasLoadMethods((const headerType *)infoList[i].imageLoadAddress)) {
        found = true;
        break;
    }
}

就會進入 load_images_nolock 去尋找 load 方法:

bool load_images_nolock(enum dyld_image_states state, uint32_t infoCount,
                        const struct dyld_image_info infoList[]) {
    bool found = NO;
    uint32_t i = infoCount;
    while (i--) {
        const headerType *mhdr = (headerType *)infoList[i].imageLoadAddress;
        if (!hasLoadMethods(mhdr)) continue;
        prepare_load_methods(mhdr);
        found = YES;
    }
    return found;
}

prepare_load_methods 負責把需要呼叫 load 的類排進佇列:

void prepare_load_methods(const headerType *mhdr) {
    size_t count, i;
    runtimeLock.assertWriting();

    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;              // 針對被忽略的弱連結類的分類
        realizeClass(cls);
        assert(cls->ISA()->isRealized());
        add_category_to_loadable_list(cat);
    }
}

拿到所有類的清單後,透過 remapClass 取得類指標,再交給 schedule_class_load 遞迴安排:

static void schedule_class_load(Class cls) {
    if (!cls) return;
    assert(cls->isRealized());
    if (cls->data()->flags & RW_LOADED) return;
    schedule_class_load(cls->superclass);   // 父類先入列
    add_class_to_loadable_list(cls);
    cls->setInfo(RW_LOADED);
}

注意這裡的順序:先把父類加入待載入清單,再處理自己。這正是「父類的 load 先於子類」的源頭。

真正呼叫 load

鏡像載入完成、準備工作就緒之後,call_load_methods 上場:

void call_load_methods(void) {
    ...
    do {
        while (loadable_classes_used > 0) {
            call_class_loads();
        }
        more_categories = call_category_loads();
    } while (loadable_classes_used > 0 || more_categories);
    ...
}

其中 call_class_loads 會從 loadable_classes 佇列取出類,找到 @selector(load) 的實作並執行:

static void call_class_loads(void) {
    int i;
    struct loadable_class *classes = loadable_classes;
    int used = loadable_classes_used;

    loadable_classes = nil;
    loadable_classes_allocated = 0;
    loadable_classes_used = 0;

    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;
        (*load_method)(cls, SEL_load);   // 就是這一行呼叫了 +[XXObject load]
    }
    if (classes) free(classes);
}

至此,第一個問題有了答案。

Q:load 方法是怎麼被呼叫的?

A:ObjC runtime 初始化時,會透過 dyld_register_image_state_change_handler 註冊回呼;每當有新鏡像加入,就執行 load_images,把所有含 load 方法的檔案排入 loadable_classes,再從這個清單裡找出實作並呼叫。

載入佇列的管理

ObjC 用了兩個清單來管理這件事:loadable_classes 與 loadable_categories。整個過程很像生產者與消費者:

add_class_to_loadable_list 負責生產,call_class_loads 負責消費;分類則走另一條類似的路 add_category_to_loadable_list。

生產 loadable_class

void add_class_to_loadable_list(Class cls) {
    IMP method;
    loadMethodLock.assertLocked();

    method = cls->getLoadMethod();
    if (!method) return;

    if (loadable_classes_used == loadable_classes_allocated) {
        loadable_classes_allocated = loadable_classes_allocated * 2 + 16;
        loadable_classes = (struct loadable_class *)realloc(loadable_classes,
            loadable_classes_allocated * sizeof(struct loadable_class));
    }

    loadable_classes[loadable_classes_used].cls = cls;
    loadable_classes[loadable_classes_used].method = method;
    loadable_classes_used++;
}

它做了四件事:取出 load 方法的 IMP;判斷陣列是否已滿;容量不足時擴容;把類與方法實作塞進清單。loadable_categories 的版本幾乎一模一樣:

void add_category_to_loadable_list(Category cat) {
    IMP method;
    loadMethodLock.assertLocked();

    method = _category_getLoadMethod(cat);
    if (!method) return;

    if (loadable_categories_used == loadable_categories_allocated) {
        loadable_categories_allocated = loadable_categories_allocated * 2 + 16;
        loadable_categories = (struct loadable_category *)realloc(loadable_categories,
            loadable_categories_allocated * sizeof(struct loadable_category));
    }

    loadable_categories[loadable_categories_used].cat = cat;
    loadable_categories[loadable_categories_used].method = method;
    loadable_categories_used++;
}

消費 loadable_class

呼叫 load 的過程就是消費 loadable_classes 的過程:

void call_load_methods(void) {
    static bool loading = NO;
    bool more_categories;
    loadMethodLock.assertLocked();

    if (loading) return;
    loading = YES;

    void *pool = objc_autoreleasePoolPush();
    do {
        while (loadable_classes_used > 0) {
            call_class_loads();
        }
        more_categories = call_category_loads();
    } while (loadable_classes_used > 0 || more_categories);
    objc_autoreleasePoolPop(pool);

    loading = NO;
}

順序可以歸納成三句話:

  • 不停呼叫類的 +load,直到 loadable_classes 清空。
  • 呼叫一次 call_category_loads 處理分類。
  • 若還有類或新的分類,繼續迴圈。

分類的處理稍微複雜一些:

static bool call_category_loads(void) {
    int i, shift;
    bool new_categories_added = NO;

    // 1. 取出當前待載入的分類清單
    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;

    for (i = 0; i < used; i++) {
        Category cat = cats[i].cat;
        load_method_t load_method = (load_method_t)cats[i].method;
        if (!cat) continue;
        Class cls = _category_getClass(cat);
        // 2. 類存在且可載入時,才呼叫分類的 load
        if (cls && cls->isLoadable()) {
            (*load_method)(cls, SEL_load);
            cats[i].cat = nil;
        }
    }

    // 3. 把已處理過的分類從清單中移除
    shift = 0;
    for (i = 0; i < used; i++) {
        if (cats[i].cat) {
            cats[i - shift] = cats[i];
        } else {
            shift++;
        }
    }
    used -= shift;

    // 4. 重新配置記憶體並寫回
    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];
    }
    if (loadable_categories) free(loadable_categories);
    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;
    }
    return new_categories_added;
}

呼叫順序的由來

關於 +load 的順序,流傳著兩條規則:父類先於子類;類先於分類。這兩條都符合我們的直覺,原因也都能在源碼裡找到。

第一條來自 schedule_class_load 中的這行遞迴:

schedule_class_load(cls->superclass);
add_class_to_loadable_list(cls);

父類總是先一步進陣列,順序自然不會亂。

第二條主要靠 call_load_methods 裡的 do-while 保證:

do {
    while (loadable_classes_used > 0) {
        call_class_loads();
    }
    more_categories = call_category_loads();
} while (loadable_classes_used > 0 || more_categories);

但這裡並不能百分之百保證。如果分類所在的鏡像比類的鏡像更早載入,順序就會失控。所以 call_category_loads 裡還多了一道手續:

if (cls && cls->isLoadable()) {
    (*load_method)(cls, SEL_load);
    cats[i].cat = nil;
}

先確認類存在且可載入,才呼叫分類的 load。兩層保險疊起來,順序才穩。

+load 的適用場景

+load 是我們日常能接觸到的最早被呼叫的方法,早到 main 函數都還沒開始。它的三個特點決定了用途:

1)呼叫時機極早,且非惰性;2)整個 App 生命週期內只呼叫一次;3)類與分類裡的 load 都會被執行,不像其他分類方法那樣被覆蓋。

這三點疊加,讓它成為方法交換(Swizzling)的理想時機。但要留意:因為跑得太早,你無法保證類別之間的載入先後;好消息是此時所有 framework 都已經載入 runtime,呼叫它們的 API 是安全的。

參考資料

NSObject +load and +initialize - What do they do?

Method Swizzling

Objective-C Class Loading and Initialization

  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved