OC 底层探索 15、类的加载3

本文继续衔接 OC 底层探索 14、类的加载2 探索分类的加载。调试源码

一、分类的本质

分类的结构查看方法

1）.cpp 文件

在 main.m 中任意添加一个分类信息的 .h .m 文件信息，编译生成cpp文件 clang -rewrite-objc main.m -o main.cpp

如下tu：

category_t 结构:

struct _category_t {
    const char *name;
    struct _class_t *cls;
    const struct _method_list_t *instance_methods;
    const struct _method_list_t *class_methods;
    const struct _protocol_list_t *protocols;
    const struct _prop_list_t *properties;
};

有 2 个 _method_list_t 分类的方法是要 attach 到本类cls上由本类进行调用的，分类是不存在元类的说法的。

2）objc 源码搜索 category_t

 

2、分类的方法 list

分类添加的属性系统不会给其生成 set/get 方法，我们可通过runtime 的 associate 进行set/get 方法的动态关联。

二、分类的加载

1、源码分析

继续OC 底层探索 14、类的加载2 对 methodizeClass() 源码分析，首先给 MyPerson 添加分类，并添加如下方法：

 

1、运行工程，方法 list 中只有本类的 2 个方法，并没有分类中的方法，见下图：

继续执行代码到 源码2的 47 行起，category 分类的 attach，此时 list 仍是有 2 个方法：

2、objc::unattachedCategories.attachToClass() 代码如下，源码1：

    void attachToClass(Class cls, Class previously, int flags)
    {
        runtimeLock.assertLocked();
        ASSERT((flags & ATTACH_CLASS) ||
               (flags & ATTACH_METACLASS) ||
               (flags & ATTACH_CLASS_AND_METACLASS));

        
        // 我加的调试代码
        const char *mangledName = cls->mangledName();
        const char *myPersonName = "MyPerson";
        if (strcmp(mangledName, myPersonName) == 0) {
            printf("%s 函数 func: %s
",__func__,mangledName);
        }
        
        auto &map = get();
        auto it = map.find(previously);

        if (it != map.end()) {
            category_list &list = it->second;
            if (flags & ATTACH_CLASS_AND_METACLASS) {
                int otherFlags = flags & ~ATTACH_CLASS_AND_METACLASS;
                attachCategories(cls, list.array(), list.count(), otherFlags | ATTACH_CLASS);
                attachCategories(cls->ISA(), list.array(), list.count(), otherFlags | ATTACH_METACLASS);
            } else {
                attachCategories(cls, list.array(), list.count(), flags);
            }
            map.erase(it);
        }
    }

但是运行并未走进 attachCategories 源码1的20行代码，我们跳进 attachCategories() 方法并对其进行断点(下面源码2的第41行)：

3、attachCategories() 源码2：

// Attach method lists and properties and protocols from categories to a class.
// Assumes the categories in cats are all loaded and sorted by load order, 
// oldest categories first.
static void
attachCategories(Class cls, const locstamped_category_t *cats_list, uint32_t cats_count,
                 int flags)
{
    if (slowpath(PrintReplacedMethods)) {
        printReplacements(cls, cats_list, cats_count);
    }
    if (slowpath(PrintConnecting)) {
        _objc_inform("CLASS: attaching %d categories to%s class '%s'%s",
                     cats_count, (flags & ATTACH_EXISTING) ? " existing" : "",
                     cls->nameForLogging(), (flags & ATTACH_METACLASS) ? " (meta)" : "");
    }

    /*
     * Only a few classes have more than 64 categories during launch.
     * This uses a little stack, and avoids malloc.
     *
     * Categories must be added in the proper order, which is back
     * to front. To do that with the chunking, we iterate cats_list
     * from front to back, build up the local buffers backwards,
     * and call attachLists on the chunks. attachLists prepends the
     * lists, so the final result is in the expected order.
     */
    constexpr uint32_t ATTACH_BUFSIZ = 64;
    method_list_t   *mlists[ATTACH_BUFSIZ];
    property_list_t *proplists[ATTACH_BUFSIZ];
    protocol_list_t *protolists[ATTACH_BUFSIZ];

    uint32_t mcount = 0;
    uint32_t propcount = 0;
    uint32_t protocount = 0;
    bool fromBundle = NO;
    bool isMeta = (flags & ATTACH_METACLASS);
    auto rwe = cls->data()->extAllocIfNeeded();// rwe 初始化 --> 要对copy出的干净内存进行方法插入操作

    
    // 我加的调试代码
    const char *mangledName = cls->mangledName();
    const char *myPersonName = "MyPerson";
    if (strcmp(mangledName, myPersonName) == 0) {
        printf("%s 函数 func: %s
",__func__,mangledName);
    }
    
    // 遍历 分类数据的准备(method property protocol)
    for (uint32_t i = 0; i < cats_count; i++) {
        auto& entry = cats_list[i];

        method_list_t *mlist = entry.cat->methodsForMeta(isMeta);
        if (mlist) {
            if (mcount == ATTACH_BUFSIZ) {
                prepareMethodLists(cls, mlists, mcount, NO, fromBundle);
                rwe->methods.attachLists(mlists, mcount);
                mcount = 0;
            }
            mlists[ATTACH_BUFSIZ - ++mcount] = mlist;// mlists 添加数据 mlist --> 从后向前 倒序插入 64-1 64-2... (二维数组)
            fromBundle |= entry.hi->isBundle();
        }

        property_list_t *proplist =
            entry.cat->propertiesForMeta(isMeta, entry.hi);
        if (proplist) {
            if (propcount == ATTACH_BUFSIZ) {
                rwe->properties.attachLists(proplists, propcount);
                propcount = 0;
            }
            proplists[ATTACH_BUFSIZ - ++propcount] = proplist;
        }

        protocol_list_t *protolist = entry.cat->protocolsForMeta(isMeta);
        if (protolist) {
            if (protocount == ATTACH_BUFSIZ) {
                rwe->protocols.attachLists(protolists, protocount);
                protocount = 0;
            }
            protolists[ATTACH_BUFSIZ - ++protocount] = protolist;
        }
    }
    // 分类方法的 排序、附着关联
    if (mcount > 0) {
        prepareMethodLists(cls, mlists + ATTACH_BUFSIZ - mcount, mcount, NO, fromBundle);// 排序
        rwe->methods.attachLists(mlists + ATTACH_BUFSIZ - mcount, mcount);// attach
        if (flags & ATTACH_EXISTING) flushCaches(cls);
    }

    rwe->properties.attachLists(proplists + ATTACH_BUFSIZ - propcount, propcount);

    rwe->protocols.attachLists(protolists + ATTACH_BUFSIZ - protocount, protocount);
}

tip：rwe 的初始化 开辟：extAllocIfNeeded()，在以下几种场景(我们可操作的)：

1. static IMP addMethod()

2. static SEL * addMethods()

3. BOOL class_addProtocol()

4. static bool _class_addProperty()

5. 分类

4、继续源码分析

attachLists() 源码3：

void attachLists(List* const * addedLists, uint32_t addedCount) {
        if (addedCount == 0) return;

        if (hasArray()) {
            // many lists -> many lists 多+多
            uint32_t oldCount = array()->count;
            uint32_t newCount = oldCount + addedCount;
            setArray((array_t *)realloc(array(), array_t::byteSize(newCount)));// 扩容
            array()->count = newCount;
            memmove(array()->lists + addedCount, array()->lists, 
                    oldCount * sizeof(array()->lists[0]));// 移动旧的去后面
            memcpy(array()->lists, addedLists, 
                   addedCount * sizeof(array()->lists[0]));// cpy 新的在前面
        }
        else if (!list  &&  addedCount == 1) {
            // 0 lists -> 1 list
            // 0到1 - list 没有数据第一次 - 第0个元素给list，此时 list 是一维的
            list = addedLists[0];
        } 
        else {
            // 1 list -> many lists
            // 1+many - 举例 many lists 是3个
            List* oldList = list;
            uint32_t oldCount = oldList ? 1 : 0;
            uint32_t newCount = oldCount + addedCount;// 容量计算，旧+新的和 1+3=4
            setArray((array_t *)malloc(array_t::byteSize(newCount)));// 开辟总大小的空间 newCount
            array()->count = newCount;// array 的数量：是新的添加 manylists 后的数量
            if (oldList) array()->lists[addedCount] = oldList;// 旧的list 放最后面 第3个位置
            // memcpy(位置, 放谁, 大小)
            // 把新的 lists 从起始位置0开始放
            memcpy(array()->lists, addedLists, 
                   addedCount * sizeof(array()->lists[0]));
        }
    }

分类的 attachLists 过程:

这里其实也可验证，为何我们天津爱的分类方法会优于本类方法调用 --> 本类方法并非被覆盖而是在后面了。 

2、源码验证

运行工程验证，如何走进 attachCategories() 呢？

给分类也添加 +load 方法，运行可以走了进去：

1、何时调用 attachCategories() 呢？

1.1. 断点 - 看堆栈信息

可以看到 load_categories_nolock() 之后走进了attachCategories()，搜索load_categories_nolock:

_read_images() 和 loadAllCategories() 两处 调了 load_categories_nolock(hi); 断点，重新运行工程，断点只走了 loadAllCategories()：

--> loadAllCategories() 是在 load_images() 时调用，map_images 已经走完了。

 

1.2. 反推

已知必然会调 attachCategories()，全局搜索 attachCategories，找到下面两处进行了调用：

1. attachToClass()
2. load_categories_nolock()

通过断点调试发现走到了 load_categories_nolock().

attachCategories 调用流程图：

问题：我们创建多个分类，只在 本类和其中一个分类中添加load方法 其他分类不加，那么不加load方法的分类是懒加载还是非懒加载处理呢？--> 下面的 ‘3’ 进行分析。

2、attachList 源码执行

执行到上面源码2的84行(同时见下图源码)：

ATTACH_BUFSIZ = 64  mcount = 1 --> 内存平移 --> 平移到最后位置。

分类的 attachLists()，走进了条件 1+多 : 

3、分类加载的几种情况

1）本类、分类均实现 load

上面的流程即使如此，全部走了 load_images() 加载到数据，文章上面的过程已可验证。

2）本类实现 load 方法非懒加载，分类都不实现 load

运行见下图，methodizeClass() 方法执行，2个分类的方法数据都在 data() 里面了。(rwe 为 NULL 未开辟脏内存，data 在 macho 中)

上图 lldb 出的信息，排序：对3者相同的方法名的排序 - 后加的分类 方法在前，本类在最后。

3）本类和分类都懒加载 不实现 load 方法

在第一次方法调用时加载到数据：

执行过程: _read_images() --> readClass(). readClass 中 baseMethodList 的 count 也是13个，数据也是从 data() 里面拿到的:

方法排序和 ‘1）’ 中相同。

4）主类不实现 load 分类实现 load

通过堆栈信息查看加载流程:

methodList 一直到 执行到 attachToClass() 仍是只有9个方法:

attachToClass() --> 走进了 attachCategories() --> attachLists() .

可得结论：分类实现了load方法会迫使主类进行提前加载数据(但这里本类仍并非是非懒加载，只是被迫使提前加载了而已)。 

5）主类和分类 cateMore 非懒加载 - cateTwo 懒加载不实现load方法:

1、运行工程，MyPerson 类第一次进入 attachCategories() -->

cateTwo 的方法加载在 data 中(ro->baseMethods())取出，rwe 为 null 未开辟脏内存.

2、继续执行 MyPerson 类第二次进入 load_categories_nolock() --> attachCategories() -->

attachLists()，rew 非 NULL，分类 cateMore 的方法会 attachLists 进来:

所有分类都会走非懒加载！！！对于同一个本类，只要有一个分类是非懒加载，其他所有分类都会非懒加载的。

总结：

• 分类懒加载： 分类的数据信息是从 data 中读取的；
• 有一 or 多个分类非懒加载：主类会提前加载(早于 main 函数)，并 attach 到所有非懒加载分类的信息；
• 都为懒加载：在第一次方法调用时从 data() 中取出数据。

---

问题回顾：通过 OC 底层探索 14 对方法排序源码的分析已知，方法排序：

1、首先根据方法名的地址进行排序 - name 的 address

2、若方法重名则根据 sel 排序：

　　1. sel 混乱则进行 fixedUp  2. sel 没有混乱则根据 imp 排序。 

验证：

文章上面的流程也可得验证。

以上。