底层原理:懒加载类与非懒加载类

上一篇文章我们分析了dyld跟objc的关联中，已经研究到了_dyld_objc_notify_register中会调用到map_images、load_images，并且对于map_images也做了一些分析。map_images中会调用map_images_nolock然后调用_read_images，_read_images源码中有这么一段:

    // 实现非懒加载(+load方法及静态实例)
    for (EACH_HEADER) {
        classref_t const *classlist = 
            _getObjc2NonlazyClassList(hi, &count);
        for (i = 0; i < count; i++) {
            Class cls = remapClass(classlist[i]);
            if (!cls) continue;

            const char *mangledName = cls->mangledName();
            const char *clsName = "LGPerson";
            if (strcmp(mangledName, clsName)==0) {
                printf("%s实现非懒加载的类，对于load方法和静态实例变量       -%s",__func__,mangledName);
            }

            addClassTableEntry(cls);

            if (cls->isSwiftStable()) {
                if (cls->swiftMetadataInitializer()) {
                    _objc_fatal("Swift class %s with a metadata initializer "
                                "is not allowed to be non-lazy",
                                cls->nameForLogging());
                }
                // fixme also disallow relocatable classes
                // We can't disallow all Swift classes because of
                // classes like Swift.__EmptyArrayStorage
            }
            realizeClassWithoutSwift(cls, nil);
        }
    }

@implementation LGPerson

+ (void)load {
    NSLog(@"LGPerson load");
}

@end

在里面我们加了一段打印，判断如果是我们自己定义的类执行到这里就打印。接下来我们在LGPerson中实现+load方法，看看打印：

_read_images实现非懒加载的类，对于load方法和静态实例变量-LGPerson
2020-10-21 08:32:48.113095+0800 KCObjc[50894:1139354] LGPerson load

接下来我们把+load方法注释掉再看看，打印没有了，说明如果不实现+load，这里面确实不会进行加载。
这里引出了我们本篇文章分析的一个话题，懒加载类与非懒加载类。
懒加载类其实就是指类的加载在第一次消息发送之前，但是如果我们在类中实现了+load方法，那么类的加载就会提前到pre-main之前,提前加载的类就称之为非懒加载类。
在上面的源码中，我们可以找到其中的关键方法realizeClassWithoutSwift。接下来我们就继续去看看realizeClassWithoutSwift。

类的加载

realizeClassWithoutSwift我们先看其源码实现，因为我们这里主要探究的是加载，其中加载具体做的事情不做过多说明，把部分源码进行了省略。

static Class realizeClassWithoutSwift(Class cls, Class previously)
{
    runtimeLock.assertLocked();
    class_rw_t *rw;
    Class supercls;
    Class metacls;
    if (!cls) return nil;
    if (cls->isRealized()) return cls;
    ASSERT(cls == remapClass(cls));
    // fixme verify class is not in an un-dlopened part of the shared cache?
    auto ro = (const class_ro_t *)cls->data();
    auto isMeta = ro->flags & RO_META;
    if (ro->flags & RO_FUTURE) {
        // This was a future class. rw data is already allocated.
        rw = cls->data();
        ro = cls->data()->ro();
        ASSERT(!isMeta);
        cls->changeInfo(RW_REALIZED|RW_REALIZING, RW_FUTURE);
    } else {
        // Normal class. Allocate writeable class data.
        rw = objc::zalloc<class_rw_t>();
        rw->set_ro(ro);
        rw->flags = RW_REALIZED|RW_REALIZING|isMeta;
        cls->setData(rw);
    }
   ...
    // Realize superclass and metaclass, if they aren't already.
    // This needs to be done after RW_REALIZED is set above, for root classes.
    // This needs to be done after class index is chosen, for root metaclasses.
    // This assumes that none of those classes have Swift contents,
    //   or that Swift's initializers have already been called.
    //   fixme that assumption will be wrong if we add support
    //   for ObjC subclasses of Swift classes.
    supercls = realizeClassWithoutSwift(remapClass(cls->superclass), nil);
    metacls = realizeClassWithoutSwift(remapClass(cls->ISA()), nil);
    ...
    // Update superclass and metaclass in case of remapping
    cls->superclass = supercls;
    cls->initClassIsa(metacls);
   ...
   return cls;
}

根据方法的注释我们可以解读出以下信息：

对类cls执行首次初始化
包括分配读写数据。
不执行任何Swift侧初始化。
返回类的实际类结构。
锁定:runtimeLock必须由调用者写锁

对方法的实现的一些概念进行解读
ro：干净内存(Clean Memory),存放的是类的原始数据
rw：脏内存(Dirty Memory) ，运行时会对类内存进行动态的修改所以才有rw，rw最初是从ro中读取的数据。
rwe：新增内容，运行时动态修改类才会生成rwe，rwe的原始数据是从rw中读取的。
supercls = realizeClassWithoutSwift(remapClass(cls->superclass), nil);沿着继承链递归调用realizeClassWithoutSwift。
metacls = realizeClassWithoutSwift(remapClass(cls->ISA()), nil);沿着isa走位递归调用realizeClassWithoutSwift。
所以如果一个类加载了，其继承链上的父类、isa对应的元类等都会加载。

懒加载类

我们实现了+load方法类的加载就会提前，+load是如何影响类的加载的时机的呢？
load_images源码中有说明在dyld映射的镜像中处理+load，我们需要去看看load_images中是如何处理+load方法的。

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.
    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)
    call_load_methods();
}

hasLoadMethods: 如果这里没有+load方法，则返回而不带锁。
从对hasLoadMethods注释我们知道，load_images是通过hasLoadMethods方法，来判断是否有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中的处理：

_getObjc2NonlazyClassList:获取所有类中的Load方法数量
_getObjc2NonlazyCategoryList:获取所有分类中的Load方法数量

load_images接下来是调用了prepare_load_methods来发现所有的load方法，并且这里是加了锁的。

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_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.其中关键的方法schedule_class_load、add_class_to_loadable_list。
2.获取非懒加载分类列表，循环遍历去加载非懒加载分类的 load 方法到 loadable_categories。
其中关键的方法add_category_to_loadable_list。
非懒加载分类遍历时，有一个处理realizeClassWithoutSwift(cls, nil)，在遍历加载非懒加载类的load方法时，会调用realizeClassWithoutSwift，如果分类对应的类没有记载，在这里就会被加载。

懒加载类

对于懒加载类，是在第一次消息发送objc_msgSend,调用到lookUpImpOrForward

IMP lookUpImpOrForward(id inst, SEL sel, Class cls, int behavior)
{
    if (slowpath(!cls->isRealized())) {
        cls = realizeClassMaybeSwiftAndLeaveLocked(cls, runtimeLock);
        // runtimeLock may have been dropped but is now locked again
    }
    return imp;
}

static Class
realizeClassMaybeSwiftAndLeaveLocked(Class cls, mutex_t& lock)
{
    return realizeClassMaybeSwiftMaybeRelock(cls, lock, true);
}
static Class
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 {
        // Swift class. We need to drop locks and call the Swift
        // runtime to initialize it.
        lock.unlock();
        cls = realizeSwiftClass(cls);
        ASSERT(cls->isRealized());    // callback must have provoked realization
        if (leaveLocked) lock.lock();
    }

    return cls;
}

我们可以清晰的看到lookUpImpOrForward中也会调用到realizeClassWithoutSwift，对类进行加载。

总结

懒加载类情况类加载延迟到第一次消息发送。
lookUpImOrForward
realizeClassMaybeSwiftMaybeRelock
relizeClassWithoutSwift
methodizeClass

非懒记载类调用了+load方法，类就会提前加载。
getObjc2NonlazyClassList
readClass
realizeClassWithoutSwift
methodizeClass