+load 和 +initialize

网上有很多关于 +load 和 +initialize 实现的，每次都是看过理解之后，没多久就忘记了，所以在此记录一下自己对 +load 和 +initialize 的理解

+load

1. 在程序启动时 系统会调用 void _objc_init(void)函数，函数中通过_dyld_objc_notify_register(&map_images, load_images, unmap_image); 注册了一个通知，在有新的镜像加入时，会进行回调。其中load_images就是执行 +load 方法的地方。

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
    {
        rwlock_writer_t lock2(runtimeLock);
        prepare_load_methods((const headerType *)mh);
    }

    // Call +load methods (without runtimeLock - re-entrant)
    call_load_methods();
}

2. load_images中 主要有两部分：prepare_load_methods call_load_methods

扫描镜像中的所有类和类别 
void prepare_load_methods(const headerType *mhdr)
{
   size_t count, i;

   runtimeLock.assertWriting();

   classref_t *classlist = 
       _getObjc2NonlazyClassList(mhdr, &count);
   for (i = 0; i < count; i++) {
       schedule_class_load(remapClass(classlist[i]));
   }

   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
       realizeClass(cls);
       assert(cls->ISA()->isRealized());
       add_category_to_loadable_list(cat);
   }
}

// schedule_class_load
static void schedule_class_load(Class cls)
{
   if (!cls) return;
   assert(cls->isRealized());  // _read_images should realize

   if (cls->data()->flags & RW_LOADED) return;

   // Ensure superclass-first ordering
   schedule_class_load(cls->superclass);

   add_class_to_loadable_list(cls);
   cls->setInfo(RW_LOADED); 
}

• 扫描镜像中的所有类和类别
• schedule_class_load 方法中利用递归按顺序遍历父类 保证保证最顶层的类放在数组的在前面 （所以不需要手动调用父类方法 系统会自动调用 ）
• 所有类、和+load 函数指针(重点 是函数指针 调用时不通过 objc_msgsend) 保存为结构体 放入 loadable_classes 数组中
• RW_LOADED 标志类有没有加入到 数组中 ，保证不会重复添加。
• 所有类别会按顺序加入 loadable_categories 数组中 同类一样 会直接使用+load 函数指针
• 函数中判断了是否存在了 +load 方法 不存在不会添加 （所以 没有实现+ load方法 就不会调用）

void call_load_methods(void)
{
    static bool loading = NO;
    bool more_categories;

    loadMethodLock.assertLocked();

    // Re-entrant calls do nothing; the outermost call will finish the job.
    if (loading) return;
    loading = YES;

    void *pool = objc_autoreleasePoolPush();
    # 主要代码
    do {
        // 1. Repeatedly call class +loads until there aren't any more
        while (loadable_classes_used > 0) {
            call_class_loads();
        }

        // 2. Call category +loads ONCE
        more_categories = call_category_loads();

        // 3. Run more +loads if there are classes OR more untried categories
    } while (loadable_classes_used > 0  ||  more_categories);

    objc_autoreleasePoolPop(pool);

    loading = NO;
}

• 此方法为实际的 +load调用所在
• 按顺序先调用 call_class_loads(); 函数内部 顺序遍历loadable_classes 执行+load方法 保证了 父类先于子类调用
• 其次调用call_category_loads()方法 顺序遍历 loadable_categories 然后通过cls->isLoadable()判断所属于的类 是否已经调用过 +load方法 1、已经调用则 调用类别+load方法 并从数组中移除 2、没有调用 则保留类别等待下次调用此函数在进行调用 此方法保证了 类别的+load一定在 所属类的 +load调用后才进行
• 以上方法保证了 +load 执行顺序 父类 -> 子类 -> 类别

3. 至此 +load方法 执行完毕 通过上述分析 得出结论：

• 在镜像加载时 自动调用
• 执行顺序 父类 -> 子类 -> 类别
• 不用显示调用 并且直接通过函数指针调用 不通过 objc_msgsend，所以如果没有实现+load方法 则不会进行调用
• 通过 RW_LOADED 来控制只会调用一次

+initialize

initialize 只会在对应类的方法第一次被调用时，才会调用。

0 +[XXObject initialize]
1 _class_initialize
2 lookUpImpOrForward
3 _class_lookupMethodAndLoadCache3
4 objc_msgSend
5 main
6 start

通过函数调用栈发现 主要实现方法在 _class_initialize 中

void _class_initialize(Class cls)
{
    Class supercls;
    BOOL reallyInitialize = NO;

    // 1. 强制父类先调用 initialize 方法
    supercls = cls->superclass;
    if (supercls  &&  !supercls->isInitialized()) {
        _class_initialize(supercls);
    }
    
    {
        // 2. 通过加锁来设置 RW_INITIALIZING 标志位
        monitor_locker_t lock(classInitLock);
        if (!cls->isInitialized() && !cls->isInitializing()) {
            cls->setInitializing();
            reallyInitialize = YES;
        }
    }
    
    if (reallyInitialize) {
        // 3. 成功设置标志位，向当前类发送 +initialize 消息
        _setThisThreadIsInitializingClass(cls);

        ((void(*)(Class, SEL))objc_msgSend)(cls, SEL_initialize);

        // 4. 完成初始化，如果父类已经初始化完成，设置 RW_INITIALIZED 标志位，
        //    否则，在父类初始化完成之后再设置标志位。
        monitor_locker_t lock(classInitLock);
        if (!supercls  ||  supercls->isInitialized()) {
            _finishInitializing(cls, supercls);
        } else {
            _finishInitializingAfter(cls, supercls);
        }
        return;
    } else if (cls->isInitializing()) {
        // 5. 当前线程正在初始化当前类，直接返回，否则，会等待其它线程初始化结束后，再返回
        if (_thisThreadIsInitializingClass(cls)) {
            return;
        } else {
            monitor_locker_t lock(classInitLock);
            while (!cls->isInitialized()) {
                classInitLock.wait();
            }
            return;
        }
    } else if (cls->isInitialized()) {
        // 6. 初始化成功后，直接返回
        return;
    } else {
        _objc_fatal("thread-safe class init in objc runtime is buggy!");
    }
}

• 注释已经很详细 同样是使用递归 保证父类先于子类的顺序调用 （所以也不需要手动调用父类方法）
• RW_INITIALIZED 保证只执行一次 （只是针对这里执行一次）

void callInitialize(Class cls)
{
    ((void(*)(Class, SEL))objc_msgSend)(cls, SEL_initialize);
    asm("");
}

• 通过上述方法发现 系统通过 objc_msgSend 来调用 initialize 方法
• 如果 运行时特性 类别方法会添加到类方法前面 且如果没有方法实现会自动查找父类实现 所以initialize 方法可能会调用多次 并且分类实现会覆盖类的实现 子类没有实现会自动调用父类实现 之前说的只调用一次 其实只是针对类本身只调用一次 但是有可能被子类触发 所以也会调用多次

至此 +initialize方法 执行完毕 通过上述分析 得出结论：

• 执行顺序 父类 -> 子类 类别会覆盖类的实现 子类没有实现会继承父类实现 导致initialize多次调用
• 不用显示调用 通过 objc_msgsend，所以如果没有实现+initialize方法 会继承父类实现
• 通过 RW_INITIALIZED 来控制 相对于本身只 初始化一次

最后 总结+load +initialize 的相同点与不同点

1. 相同点

• 都是类方法
• 都不需要显示调用，系统会自动调用
• 不用显示调用父类方法

2. 不同点

• 调用时机不同。 + load 是程序启动 新的镜像被加载到 runtime 时，回调 load_images 方法里面进行调用、 + initialize 只会在对应类的方法第一次被调用时，才会调用。
• 调用方式不同。 +load 是直接获取 IMP 来执行，不同通过消息查找和转发 ，+ initialize通过objc_msgsend调用 会通过runtime进行消息发送
• 调用顺序不同 +load 父类 -> 子类 -> 类别 。 + initialize 父类 -> 子类, 类别会覆盖类的实现 子类没有实现会继承父类实现
• +load 不会继承父类实现，如果没有实现就不调用 + initialize 会继承父类实现，没有实现就使用父类方法
• 调用次数不同 + load 只会调用一次 + initialize 可能会调用多次

注意 上述所说 不会继承 只是针对系统的自动调用 不会主动沿用父类实现 如果手动通过 [xxx load]、[xxx initialize] 发消息与普通消息保持一致

参考博客

你真的了解 load 方法么？

懒惰的 initialize