iOS 底层探索：类的加载中（类的懒加载和非懒加载）

iOS 底层探索： 学习大纲 OC篇

前言

• 在上篇文章中，我们知道dyld在main()函数之前，会调用runtime的_objc_init 方法。_objc_init是runtime的入口函数，通过跨库通知_dyld_objc_notify_register，实现类的加载，使dyld和objc关联，但是上篇文章中提到类的加载会分懒加载和非懒加载，所以今天我们分析下类的懒加载和非懒加载的情况。

准备工作

• 复习：iOS 底层探索：类的加载上(dyld和objc关联)

• 学习参考：Objc源码之Load方法实现

一 、 非懒加载类情况 与load方法

在上一篇分析中load_images函数是对 load 方法的加载和调用，在read_image中有一段实现类的加载的代码，我们经过lldb调试会出现如下情况。

类中写了+（void）Load方法的时候如图

• 这里实现了 非懒加载类的加载

如果不写+（void）Load方法如图：

• 这里没有实现了 非懒加载类的加载

所以我们可以看出： 当一个类实现了+(void)load方法后, 它就会由懒加载类变成非懒加载类，load方法 在我们类的加载方法中改变了类的加载顺序。如果实现了 load方法，那么这个类就会提前被加载，所以我们分析一下，load方法是如何影响类的加载的。

在load_images 源码中查看：

void
load_images(const char *path __unused, const struct mach_header *mh)
{
    if (!didInitialAttachCategories && didCallDyldNotifyRegister) {
        didInitialAttachCategories = true;
        loadAllCategories();
    }

    // Return without taking locks if there are no +load methods here.
    // 判断是否有load 方法
    if (!hasLoadMethods((const headerType *)mh)) return;

    recursive_mutex_locker_t lock(loadMethodLock);

    // Discover load methods
    {
        mutex_locker_t lock2(runtimeLock);
        // 准备加载方法
        prepare_load_methods((const headerType *)mh);
    }
    
    // Call +load methods (without runtimeLock - re-entrant)
    // 调用 load 方法
    call_load_methods();
}

我们可以知道，通过hasLoadMethods方法，来判断是否有Load方法，下面我们看下Load方法的实现

bool hasLoadMethods(const headerType *mhdr)
{
    size_t count;
    if (_getObjc2NonlazyClassList(mhdr, &count)  &&  count > 0) return true;
    if (_getObjc2NonlazyCategoryList(mhdr, &count)  &&  count > 0) return true;
    return false;
}

hasLoadMethods中分为两步：

• 1. 通过_getObjc2NonlazyClassList获取所有类中的Load方法数量;
• 2. 通过 _getObjc2NonlazyCategoryList获取所有Category中的Load方法数量.

在通过hasLoadMethods判断有Load方法以后，我们需要知道具体有哪些Load方法，读取所有的load方法，这一步是通过prepare_load_methods来完成的，会将所有load方法读取到一个列表中。下面是prepare_load_methods的具体实现：

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++) {
        // 循环遍历去加载非懒加载类的 load 方法到 loadable_classes
        // schedule：安排，预定
        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());
        
        // 循环遍历去加载非懒加载分类的 load 方法到 loadable_categories
        // 和非懒加载类差不多，就是数组不一样
        add_category_to_loadable_list(cat);
    }
}

prepare_load_methods主要分为两部分：

1）获取所有类的Load方法，添加到列表（loadable_classes）中。

这一步是通过_getObjc2NonlazyClassList获取类列表，然后通过schedule_class_load递归添加数组中，我们知道父类的Load方法是早于子类的方法调用，就是在这一步处理的下面我们看下schedule_class_load方法的具体实现：

static void schedule_class_load(Class cls)
{
    if (!cls) return;
    assert(cls->isRealized());  // _read_images should realize
    //1.判断类的load方法是否添加过
    if (cls->data()->flags & RW_LOADED) return;

    // 2.保证父类优先于子类调用
    schedule_class_load(cls->superclass);

    //3.将类添加到数组中，并标注类方法已添加
    add_class_to_loadable_list(cls);
    cls->setInfo(RW_LOADED); 
}

schedule_class_load中主要做了一下事情：

• 1.判断类的load方法是否添加过
• 2.递归调用父类，保证父类先于子类执行。
• 3.将类通过add_class_to_loadable_list添加到loadable_classes中。

add_class_to_loadable_list源码如下：

void add_class_to_loadable_list(Class cls)
{
    IMP method;

    loadMethodLock.assertLocked();
    
    //1.从class_ro_t中获取load方法
    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());
    }
    
    //2.如果内存已满的话，申请现有内存2倍的内存空间
    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));
    }
    
    //3.保存多有类和方法到loadable_classes中
    loadable_classes[loadable_classes_used].cls = cls;
    loadable_classes[loadable_classes_used].method = method;
    loadable_classes_used++;
}

add_class_to_loadable_list内容主要分为以下几步：

• 1.从class_ro_t中获取load方法
• 2.如果内存已满，申请现有内存2倍的内存空间
• 3.保存多有类和方法到loadable_classes中

2）获取Category类的Load方法，添加到列表（loadable_categories）中。

category类中的加载过程和类的加载在过程基本一致，不同的是，load方法最终会加载到loadable_categories列表中。

总结：
类中的load方法都加载到loadable_classes列表中;
Category的load方法都加载到loadable_categories列表中。

二 、懒加载类的情况

我们已经知道了当一个类被调用了才会去加载这个类. 当我们对一个类进行调用, 那么肯定就会通过objc_msgSend()来发送消息了. 来到我们熟悉的lookUpImpOrForward(), 其中会有对类的一个判断:

IMP lookUpImpOrForward(id inst, SEL sel, Class cls, int behavior)
{
    ................
    checkIsKnownClass(cls);

    if (slowpath(!cls->isRealized())) {
        cls = realizeClassMaybeSwiftAndLeaveLocked(cls, runtimeLock);
        // runtimeLock may have been dropped but is now locked again
    }
     ................
 }

realizeClassMaybeSwiftMaybeRelock(Class cls, mutex_t& lock, bool leaveLocked)
{
    lock.assertLocked();

    if (!cls->isSwiftStable_ButAllowLegacyForNow()) {
        // Non-Swift class. Realize it now with the lock still held.
        // fixme wrong in the future for objc subclasses of swift classes
        realizeClassWithoutSwift(cls, nil); //重点
        if (!leaveLocked) lock.unlock();
    } else {...... }

    return cls;
}

紧跟着进入之后最终会来到realizeClassWithoutSwift()方法。

三 、总结

四 、拓展

官方在对类进行处理的时候, 为了提高对类处理的效率以及性能, 就对类进行了识别, 当类需要使用的时候, 系统才会对类进行实现. 如果没有使用就不会实现. 当需要实现才进行加载的类就被称为懒加载类. 反之无论是否使用到这个类, 都对这个类进行加载的类就被称为非懒加载类.

Load方法作为OC中一个特殊的方法，在Main函数之前执行，由于这个特性的存在，一方面可以用来在应用执行前，进行一些准备工作，由于Load方法在Mian函数之前执行，如果使用不当，会引起app启动超时、甚至出现crash，使app不能启动，因此要详细了解Load方法，并正确的使用它。