上一篇文章我们分析了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();
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