在类的加载这篇文章中，_read_images这个函数中我们分析到doneOnce,类的插入表，重映射和非懒加载类的加载过程，还有分类里面的数据是怎么加载的我们还没有分析，今天我们继续。
1、懒加载类和非懒加载类
在_read_images中我们发现有一段代码是处理非懒加载类的
// Realize non-lazy classes (for +load methods and static instances)
// 实现非懒加载的类，对于load方法和静态实例变量
for (EACH_HEADER) {
classref_t *classlist =
_getObjc2NonlazyClassList(hi, &count);
for (i = 0; i < count; i++) {
Class cls = remapClass(classlist[i]);
// ✅我们在这里打印一下类，看一下非懒加载类是什么时候初始化
printf("non-lazy Class:%s\n",cls->mangledName());
// 省略代码
// 实现所有非懒加载的类(实例化类对象的一些信息，例如rw)
realizeClassWithoutSwift(cls);
}
}
我们在一个工程中创建三个类LGPerson、LGStudent和 LGTeacher，我们执行打印一下：
non-lazy Class:OS_dispatch_queue
non-lazy Class:OS_dispatch_channel
non-lazy Class:OS_dispatch_source
non-lazy Class:OS_dispatch_mach
non-lazy Class:OS_dispatch_queue_runloop
non-lazy Class:OS_dispatch_semaphore
non-lazy Class:OS_dispatch_group
non-lazy Class:OS_dispatch_workloop
non-lazy Class:OS_dispatch_queue_serial
non-lazy Class:OS_dispatch_queue_concurrent
non-lazy Class:OS_dispatch_queue_main
non-lazy Class:OS_dispatch_queue_global
non-lazy Class:OS_dispatch_queue_pthread_root
non-lazy Class:OS_dispatch_queue_mgr
non-lazy Class:OS_dispatch_queue_attr
non-lazy Class:OS_dispatch_mach_msg
non-lazy Class:OS_dispatch_io
non-lazy Class:OS_dispatch_operation
non-lazy Class:OS_dispatch_disk
non-lazy Class:OS_voucher
non-lazy Class:OS_dispatch_data_empty
non-lazy Class:OS_xpc_connection
non-lazy Class:OS_xpc_service
non-lazy Class:OS_xpc_null
non-lazy Class:OS_xpc_bool
non-lazy Class:OS_xpc_double
non-lazy Class:OS_xpc_pointer
non-lazy Class:OS_xpc_date
non-lazy Class:OS_xpc_data
non-lazy Class:OS_xpc_string
non-lazy Class:OS_xpc_uuid
non-lazy Class:OS_xpc_fd
non-lazy Class:OS_xpc_shmem
non-lazy Class:OS_xpc_mach_send
non-lazy Class:OS_xpc_array
non-lazy Class:OS_xpc_dictionary
non-lazy Class:OS_xpc_error
non-lazy Class:OS_xpc_endpoint
non-lazy Class:OS_xpc_serializer
non-lazy Class:OS_xpc_pipe
non-lazy Class:OS_xpc_mach_recv
non-lazy Class:OS_xpc_bundle
non-lazy Class:OS_xpc_service_instance
non-lazy Class:OS_xpc_activity
non-lazy Class:OS_xpc_file_transfer
non-lazy Class:OS_xpc_int64
non-lazy Class:OS_xpc_uint64
non-lazy Class:OS_os_log
non-lazy Class:OS_os_activity
non-lazy Class:__IncompleteProtocol
non-lazy Class:Protocol
non-lazy Class:__NSUnrecognizedTaggedPointer
non-lazy Class:NSObject
non-lazy Class:__NSArray0
non-lazy Class:__NSPlaceholderArray
non-lazy Class:__NSPlaceholderSet
non-lazy Class:NSConstantArray
non-lazy Class:__NSDictionary0
non-lazy Class:NSConstantDictionary
non-lazy Class:__NSPlaceholderDate
non-lazy Class:__NSPlaceholderTimeZone
non-lazy Class:__NSPlaceholderOrderedSet
non-lazy Class:NSConstantDate
non-lazy Class:__NSPlaceholderDictionary
non-lazy Class:NSConstantIntegerNumber
non-lazy Class:NSConstantFloatNumber
non-lazy Class:NSConstantDoubleNumber
non-lazy Class:NSApplication
non-lazy Class:NSBinder
non-lazy Class:NSColorSpaceColor
non-lazy Class:NSNextStepFrame
non-lazy Class:_DKEventQuery
non-lazy Class:LGTeacher
non-lazy Class:LGStudent
看我们控制台打印出了一堆东西，但是我们仔细看发现只打印出了LGTeacher和LGStudent，为什么没有LGPerson呢？
2020-01-20 17:20:04.051474+0800 objc-debug[20679:803821] +[LGTeacher load]
2020-01-20 17:20:04.051925+0800 objc-debug[20679:803821] +[LGStudent load]
看到这两行打印，也许大家就明白了，LGTeacher和LGStudent里面实现了+ (void)load方法
-
load方法的调用是在主函数之前，系统先帮你把这个类进行初始化，不管你有没有用到，这就是非懒加载类 -
懒加载的类就是没有实现
load方法，系统没有帮你进行初始化，是需要你在用到的时候才进行初始化的
在类的加载中我们分析了非懒加载类是如何读取数据和进行rw和ro操作的，那么懒加载类是什么时候进行这些操作的呢？
懒加载类操作rw和ro
刚我们还说懒加载类是在我们用的时候进行初始化，也就是alloc。在消息查找流程-慢速查找中，消息会来到lookUpImpOrForward,在这个函数中有一段代码：
// ✅ 这里判断是否是懒加载，如果是懒加载则执行
if (!cls->isRealized()) {
cls = realizeClassMaybeSwiftAndLeaveLocked(cls, runtimeLock);
// runtimeLock may have been dropped but is now locked again
}
我们根据这个源码往下查找：
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);
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;
}
在这里我们可以看到，懒加载经过消息转发最后又回到realizeClassWithoutSwift方法，和非懒加载类进行一模模一样样的执行。
2、类和分类的搭配分析
2.1、懒加载类+非懒加载分类
上面我们分析到，非懒加载肯定会执行_read_images,_read_images里面有这样一段处理分类的代码：
// ✅ 发现和处理所有Category
for (EACH_HEADER) {
// ✅ 外部循环遍历找到当前类，查找类对应的Category数组
category_t **catlist =
_getObjc2CategoryList(hi, &count);
bool hasClassProperties = hi->info()->hasCategoryClassProperties();
for (i = 0; i < count; i++) {
// ✅ 内部循环遍历当前类的所有Category
category_t *cat = catlist[i];
Class cls = remapClass(cat->cls);
if (!cls) {
// Category's target class is missing (probably weak-linked).
// Disavow any knowledge of this category.
catlist[i] = nil;
if (PrintConnecting) {
_objc_inform("CLASS: IGNORING category \?\?\?(%s) %p with "
"missing weak-linked target class",
cat->name, cat);
}
continue;
}
// Process this category.
// First, register the category with its target class.
// Then, rebuild the class's method lists (etc) if
// the class is realized.
// ✅ 首先，通过其所属的类注册Category。如果这个类已经被实现，则重新构造类的方法列表。
bool classExists = NO;
if (cat->instanceMethods || cat->protocols
|| cat->instanceProperties)
{
// ✅ 将Category添加到对应Class的value中，value是Class对应的所有category数组
addUnattachedCategoryForClass(cat, cls, hi);
// ✅ 将Category的method、protocol、property添加到Class
if (cls->isRealized()) {
remethodizeClass(cls);
classExists = YES;
}
if (PrintConnecting) {
_objc_inform("CLASS: found category -%s(%s) %s",
cls->nameForLogging(), cat->name,
classExists ? "on existing class" : "");
}
}
// ✅ 这块和上面逻辑一样，区别在于这块是对Meta Class做操作，而上面则是对Class做操作
// ✅ 根据下面的逻辑，从代码的角度来说，是可以对原类添加Category的
if (cat->classMethods || cat->protocols
|| (hasClassProperties && cat->_classProperties))
{
addUnattachedCategoryForClass(cat, cls->ISA(), hi);
if (cls->ISA()->isRealized()) {
remethodizeClass(cls->ISA());
}
if (PrintConnecting) {
_objc_inform("CLASS: found category +%s(%s)",
cls->nameForLogging(), cat->name);
}
}
}
}
我们知道非懒加载类会实现load方法，在_objc_init中_dyld_objc_notify_register(&map_images, load_images, unmap_image);这三个参数load_images,我们进去看看：
void
load_images(const char *path __unused, const struct mach_header *mh)
{
// 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();
}
在这里的作用域里面调用了prepare_load_methods函数：
void prepare_load_methods(const headerType *mhdr)
{
size_t count, i;
runtimeLock.assertLocked();
classref_t *classlist =
_getObjc2NonlazyClassList(mhdr, &count);
for (i = 0; i < count; i++) {
schedule_class_load(remapClass(classlist[i]));
}
// ✅ 在这里获取非懒加载categorylist，如果存在，则进行realizeClassWithoutSwift
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; // 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);
assert(cls->ISA()->isRealized());
add_category_to_loadable_list(cat);
}
}
在prepare_load_methods函数中获取到非懒加载的categoryList,如果存在非懒加载categoryList，就会在此时调用realizeClassWithoutSwift方法来初始化该class，然后开始调用methodizeClass方法，在methodizeClass方法中就会开始绑定categoryList到对应的class,代码如下：
static void methodizeClass(Class cls)
{
runtimeLock.assertLocked();
bool isMeta = cls->isMetaClass();
auto rw = cls->data();
auto ro = rw->ro;
// Methodizing for the first time
if (PrintConnecting) {
_objc_inform("CLASS: methodizing class '%s' %s",
cls->nameForLogging(), isMeta ? "(meta)" : "");
}
// Install methods and properties that the class implements itself.
method_list_t *list = ro->baseMethods();
if (list) {
prepareMethodLists(cls, &list, 1, YES, isBundleClass(cls));
rw->methods.attachLists(&list, 1);
}
property_list_t *proplist = ro->baseProperties;
if (proplist) {
rw->properties.attachLists(&proplist, 1);
}
protocol_list_t *protolist = ro->baseProtocols;
if (protolist) {
rw->protocols.attachLists(&protolist, 1);
}
// Root classes get bonus method implementations if they don't have
// them already. These apply before category replacements.
if (cls->isRootMetaclass()) {
// root metaclass
addMethod(cls, SEL_initialize, (IMP)&objc_noop_imp, "", NO);
}
// Attach categories.
// ✅
category_list *cats = unattachedCategoriesForClass(cls, true /*realizing*/);
attachCategories(cls, cats, false /*don't flush caches*/);
...省略代码
}
懒加载类本来是在发送消息的时候才开始初始化，但是因为分类是非懒加载的需要提前初始化，经过read_images 但是没有实现类,在load_iamges的prepare_load_methods提前实现了类的初始化realizeClassWithoutSwift.
2.2、懒加载类+懒加载分类
我们知道，懒加载是在初始化的时候发送消息，调用lookupImpOrForward方法，方法流程跟上面懒加载是一样的。
2.3、非懒加载类+懒加载分类
因为类为非懒加载，直接执行read_iamges方法，进行非懒加载类执行过程，而懒加载的分类直接在编译时加载在ro里面了。
2.4、非懒加载类+非懒加载分类
在read_images方法里面处理类和分类的一段代码
// ✅ 首先，通过其所属的类注册Category。如果这个类已经被实现，则重新构造类的方法列表。
bool classExists = NO;
if (cat->instanceMethods || cat->protocols
|| cat->instanceProperties)
{
// ✅ 将Category添加到对应Class的value中，value是Class对应的所有category数组
addUnattachedCategoryForClass(cat, cls, hi);
// ✅ 将Category的method、protocol、property添加到Class
if (cls->isRealized()) {
remethodizeClass(cls);
classExists = YES;
}
if (PrintConnecting) {
_objc_inform("CLASS: found category -%s(%s) %s",
cls->nameForLogging(), cat->name,
classExists ? "on existing class" : "");
}
}
// ✅ 这块和上面逻辑一样，区别在于这块是对Meta Class做操作，而上面则是对Class做操作
// ✅ 根据下面的逻辑，从代码的角度来说，是可以对原类添加Category的
if (cat->classMethods || cat->protocols
|| (hasClassProperties && cat->_classProperties))
{
addUnattachedCategoryForClass(cat, cls->ISA(), hi);
if (cls->ISA()->isRealized()) {
remethodizeClass(cls->ISA());
}
if (PrintConnecting) {
_objc_inform("CLASS: found category +%s(%s)",
cls->nameForLogging(), cat->name);
}
}
我们在分类中添加的是类方法，会被存储在元类中，所以，我们只需关注：
// ✅ 根据下面的逻辑，从代码的角度来说，是可以对原类添加Category的
if (cat->classMethods || cat->protocols
|| (hasClassProperties && cat->_classProperties))
{
addUnattachedCategoryForClass(cat, cls->ISA(), hi);
if (cls->ISA()->isRealized()) {
remethodizeClass(cls->ISA());
}
if (PrintConnecting) {
_objc_inform("CLASS: found category +%s(%s)",
cls->nameForLogging(), cat->name);
}
}
这里会进入到remethodizeClass:
static void remethodizeClass(Class cls)
{
category_list *cats;
bool isMeta;
runtimeLock.assertLocked();
isMeta = cls->isMetaClass();
// Re-methodizing: check for more categories
if ((cats = unattachedCategoriesForClass(cls, false/*not realizing*/))) {
if (PrintConnecting) {
_objc_inform("CLASS: attaching categories to class '%s' %s",
cls->nameForLogging(), isMeta ? "(meta)" : "");
}
attachCategories(cls, cats, true /*flush caches*/);
free(cats);
}
}
然后添加分类attachCategories:
static void
attachCategories(Class cls, category_list *cats, bool flush_caches)
{
if (!cats) return;
if (PrintReplacedMethods) printReplacements(cls, cats);
bool isMeta = cls->isMetaClass();
// fixme rearrange to remove these intermediate allocations
method_list_t **mlists = (method_list_t **)
malloc(cats->count * sizeof(*mlists));
property_list_t **proplists = (property_list_t **)
malloc(cats->count * sizeof(*proplists));
protocol_list_t **protolists = (protocol_list_t **)
malloc(cats->count * sizeof(*protolists));
// Count backwards through cats to get newest categories first
int mcount = 0;
int propcount = 0;
int protocount = 0;
int i = cats->count;
bool fromBundle = NO;
while (i--) {
auto& entry = cats->list[i];
method_list_t *mlist = entry.cat->methodsForMeta(isMeta);
if (mlist) {
mlists[mcount++] = mlist;
fromBundle |= entry.hi->isBundle();
}
property_list_t *proplist =
entry.cat->propertiesForMeta(isMeta, entry.hi);
if (proplist) {
proplists[propcount++] = proplist;
}
protocol_list_t *protolist = entry.cat->protocols;
if (protolist) {
protolists[protocount++] = protolist;
}
}
auto rw = cls->data();
prepareMethodLists(cls, mlists, mcount, NO, fromBundle);
rw->methods.attachLists(mlists, mcount);
free(mlists);
if (flush_caches && mcount > 0) flushCaches(cls);
rw->properties.attachLists(proplists, propcount);
free(proplists);
rw->protocols.attachLists(protolists, protocount);
free(protolists);
}
看到这里是不是跟类的加载这篇文章中处理非懒加载类很像。
网友评论