• +load方法會(huì)在程序初始化時(shí)候調(diào)用
• 每個(gè)類和分類的+load方法都會(huì)調(diào)用饥悴，并且只調(diào)用一次
• 調(diào)用順序
  1. 先調(diào)用類中的+load
  按照編譯順序調(diào)用缔恳，先編譯的先調(diào)用
  父類優(yōu)先調(diào)用。調(diào)用子類的+load方法之前會(huì)先調(diào)用父類的+load
  2. 后調(diào)用category中的+load
  按照編譯順序調(diào)用，先編譯的先調(diào)用

源碼分析

源碼版本objc4-781.tar.gz

入口：objc-os.mm
void _objc_init(void)
void load_images(const char *path __unused, const struct mach_header *mh)
void prepare_load_methods(const headerType *mhdr)
void call_load_methods(void)
static void call_class_loads(void)
static bool call_category_loads(void)

先看調(diào)用情況意荤，查看void call_load_methods(void)方法可知蹦玫，先調(diào)用了類的+load方法赎婚，再調(diào)用category中的+load方法。

/***********************************************************************
* call_load_methods
* Call all pending class and category +load methods.
* Class +load methods are called superclass-first. 
* Category +load methods are not called until after the parent class's +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
* 2. Call category +loads ONCE.
* 3. Run more +loads if:
*    (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;
}

static void call_class_loads(void) 調(diào)用類的+load樱溉。源碼中比較關(guān)鍵點(diǎn)是loadable_classes這個(gè)列表挣输，其中保存了類的+load方法，循環(huán)獲取到+load方法后直接調(diào)用福贞。所以了解了loadable_classes的初始化撩嚼，就知道了類中+load方法調(diào)用的順序。

/***********************************************************************
* 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; // load方法列表 
    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方法
        load_method_t load_method = (load_method_t)classes[i].method;
        if (!cls) continue; 

        if (PrintLoading) {
            _objc_inform("LOAD: +[%s load]\n", cls->nameForLogging());
        }
        // 直接調(diào)用+load方法
        (*load_method)(cls, @selector(load));
    }
    
    // Destroy the detached list.
    if (classes) free(classes);
}

在 static bool call_category_loads(void)方法中的調(diào)用情況類似，其中有個(gè)名為loadable_categories的列表完丽，循環(huán)獲取到category中的+load方法后直接調(diào)用恋技。所以了解了loadable_categories的初始化，就知道了category中+load方法調(diào)用的順序逻族。

/***********************************************************************
* call_category_loads
* Call some pending category +load methods.
* The parent class of the +load-implementing categories has all of 
*   its categories attached, in case some are lazily waiting for +initalize.
* Don't call +load unless the parent class is connected.
* If new categories become loadable, +load is NOT called, and they 
*   are added to the end of the loadable list, and we return TRUE.
* Return FALSE if no new categories became loadable.
*
* Called only by call_load_methods().
**********************************************************************/
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, @selector(load));
            cats[i].cat = nil;
        }
    }
    ... 以下省略 ...
    ... ...
    ... ...
}

void prepare_load_methods(const headerType *mhdr)該方法就是用來(lái)初始化loadable_classes和loadable_categories的蜻底。

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

    runtimeLock.assertLocked();

    classref_t const *classlist = 
        _getObjc2NonlazyClassList(mhdr, &count);
    for (i = 0; i < count; i++) {
        schedule_class_load(remapClass(classlist[i]));
    }

    category_t * const *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, nil);
        ASSERT(cls->ISA()->isRealized());
        add_category_to_loadable_list(cat);
    }
}

其中首先調(diào)用了static void schedule_class_load(Class cls)方法，加載類中的+load聘鳞。并且該方法中存在遞歸調(diào)用薄辅，在當(dāng)前的類的+load方法添加到數(shù)組之前，會(huì)先將父類作為參數(shù)遞歸調(diào)用該方法抠璃，如果父類沒(méi)有加載過(guò)站楚，就先加載父類。確保父類比子類先加載
void add_class_to_loadable_list(Class cls)中直接將類賦值給類數(shù)組鸡典，所以先加載的在數(shù)組的前面源请，這樣就可以確保父類的+load方法在子類之前。保證了后面的調(diào)用順序

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

    add_class_to_loadable_list(cls);
    cls->setInfo(RW_LOADED); 
}

/***********************************************************************
* add_class_to_loadable_list
* Class cls has just become connected. Schedule it for +load if
* it implements a +load method.
**********************************************************************/
void add_class_to_loadable_list(Class cls)
{
    IMP method;

    loadMethodLock.assertLocked();

    method = cls->getLoadMethod();
    if (!method) return;  // Don't bother if cls has no +load method
    
    if (PrintLoading) {
        _objc_inform("LOAD: class '%s' scheduled for +load", 
                     cls->nameForLogging());
    }
    
    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++;
}

加載category中的+load方法則比較簡(jiǎn)單,調(diào)用void add_category_to_loadable_list(Category cat)彻况，直接按照編譯的順序谁尸，先編譯的在前面

/***********************************************************************
* add_category_to_loadable_list
* Category cat's parent class exists and the category has been attached
* to its class. Schedule this category for +load after its parent class
* becomes connected and has its own +load method called.
**********************************************************************/
void add_category_to_loadable_list(Category cat)
{
    IMP method;

    loadMethodLock.assertLocked();

    method = _category_getLoadMethod(cat);

    // Don't bother if cat has no +load method
    if (!method) return;

    if (PrintLoading) {
        _objc_inform("LOAD: category '%s(%s)' scheduled for +load", 
                     _category_getClassName(cat), _category_getName(cat));
    }
    
    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++;
}