+load

+load 方法是当类或分类被添加到 Objective-C runtime 时被调用的，实现这个方法可以让我们在类加载的时候执行一些类相关的行为。子类的 +load 方法会在它的所有父类的 +load 方法之后执行，而分类的 +load 方法会在它的主类的 +load 方法之后执行。但是不同的类之间的 +load 方法的调用顺序是不确定的，根据编译顺序来决定。

+initialize

+initialize 方法是在类或它的子类收到第一条消息之前被调用的，这里所指的消息包括实例方法和类方法的调用。也就是说 +initialize 方法是以懒加载的方式被调用的，如果程序一直没有给某个类或它的子类发送消息，那么这个类的 +initialize 方法是永远不会被调用的。那这样设计有什么好处呢？好处是显而易见的，那就是节省系统资源，避免浪费。

总结

通过阅读 runtime 的源码，我们知道了 +load 和 +initialize 方法实现的细节，明白了它们的调用机制和各自的特点。下面我们绘制一张表格，以更加直观的方式来巩固我们对它们的理解：

+load
调用时机 被添加到 runtime 时
调用顺序 父类->子类->分类
调用次数 1次
是否需要显式调用父类实现 否
是否沿用父类的实现 否
分类中的实现 类和分类都执行

+initialize
调用时机 收到第一条消息前，可能永远不调用
调用顺序 父类->子类
调用次数 多次
是否需要显式调用父类实现 否
是否沿用父类的实现 是
分类中的实现 覆盖类中的方法，只执行分类的实现

原理

“源码面前没有秘密”。最后，我们来看看苹果开放出来的部分源码。从中我们也许能明白为什么load和initialize及调用会有如上的一些特点。

其中load是在objc库中一个load_images函数中调用的，先把二进制映像文件中的头信息取出，再解析和读出各个模块中的类定义信息，把实现了load方法的类和Category记录下来，最后统一执行调用。

其中的prepare_load_methods函数实现如下：

 void prepare_load_methods(header_info *hi)
{
     size_t count, i;

     rwlock_assert_writing(&runtimeLock);

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

     category_t **categorylist = _getObjc2NonlazyCategoryList(hi, &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);
     }
}

这大概就是主类中的load方法先于category的原因。再看下面这段：

 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); 
 }

这正是父类load方法优先于子类调用的原因。

再来看下initialize调用相关的源码。objc的库里有一个_class_initialize方法实现，如下：

 void _class_initialize(Class cls)
 {
      assert(!cls->isMetaClass());

      Class supercls;
      BOOL reallyInitialize = NO;

      supercls = cls->superclass;
      if (supercls  &&  !supercls->isInitialized()) {
           _class_initialize(supercls);
      }

      monitor_enter(&classInitLock);
      if (!cls->isInitialized() && !cls->isInitializing()) {
          cls->setInitializing();
          reallyInitialize = YES;
      }
      monitor_exit(&classInitLock);

      if (reallyInitialize) {
          _setThisThreadIsInitializingClass(cls);

          if (PrintInitializing) {
               _objc_inform("INITIALIZE: calling +[%s initialize]",
                     cls->nameForLogging());
          }

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

          if (PrintInitializing) {
              _objc_inform("INITIALIZE: finished +[%s initialize]",
                     cls->nameForLogging());
          }

          monitor_enter(&classInitLock);
          if (!supercls  ||  supercls->isInitialized()) {
              _finishInitializing(cls, supercls);
          } else {
              _finishInitializingAfter(cls, supercls);
          }
          monitor_exit(&classInitLock);
          return;
     }

     else if (cls->isInitializing()) {
         if (_thisThreadIsInitializingClass(cls)) {
              return;
         } else {
              monitor_enter(&classInitLock);
              while (!cls->isInitialized()) {
                   monitor_wait(&classInitLock);
              }
              monitor_exit(&classInitLock);
              return;
         }
    }

    else if (cls->isInitialized()) {
         return;
    }

    else {
         _objc_fatal("thread-safe class init in objc runtime is buggy!");
    }
   }

在这段代码里，我们能看到initialize的调用顺序和线程安全性。