iOS Programmingobjcruntime
, ,

load和initialize

文章目录
  1. 1. + load
    1. 1.1. load 方法的调用栈
  2. 2. initialize
    1. 2.1. 分析 initialize

+ load

  1. load 是通过 c 函数调用的
  2. load 调用在 main 函数之前，动态链接器通知调用 load_images，执行load 方法
  3. load 加载顺序：父类-> 类-> 分类
  4. load 方法中最常用的就是方法交换 method swizzling

load 方法的调用栈

在 + load 方法出打断点，查看 load 调用栈

1
2
3
4
5
6
0  +[XXObject load]
1  call_class_loads()
2  call_load_methods
3  load_images
4  dyld::notifySingle(dyld_image_states, ImageLoader const*)
11 _dyld_start

dyld(dynamic link editor)，它是苹果的动态链接器。
在系统内核做好程序准备工作之后，交由 dyld 负责余下的工作

在 runtime 时调用 load_images 方法,那么就看下他的源码(objc4-756.2)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
/***********************************************************************
* load_images
* Process +load in the given images which are being mapped in by dyld.
*
* Locking: write-locks runtimeLock and loadMethodLock
**********************************************************************/
extern bool hasLoadMethods(const headerType *mhdr);
extern void prepare_load_methods(const headerType *mhdr); 
void load_images(const char *path __unused, const struct mach_header *mh) {
  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();
}

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

  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
* Schedule +load for classes in this image, any un-+load-ed 
* superclasses in other images, and any categories in this image.
**********************************************************************/
// Recursively schedule +load for cls and any un-+load-ed superclasses.
// cls must already be connected.
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); 
}

/***********************************************************************
* add_class_to_loadable_list
* Class cls has just become connected. Schedule it for +load if
* it implements a +load method.
**********************************************************************/
void add_class_to_loadable_list(Class cls) {
  IMP method;

  method = cls->getLoadMethod();
  if (!method) return;  // Don't bother if cls has no +load method
  
  if (loadable_classes_used == loadable_classes_allocated) {
    loadable_classes_allocated = loadable_classes_allocated*2 + 16;
    // 分配类对象空间，加载类
    loadable_classes = (struct loadable_class *)
      realloc(loadable_classes,
                loadable_classes_allocated *
                sizeof(struct loadable_class));
  }
  
  loadable_classes[loadable_classes_used].cls = cls;
  loadable_classes[loadable_classes_used].method = method;
  loadable_classes_used++;
}

/***********************************************************************
* call_load_methods
* Call all pending class and category +load methods.
* Class +load methods are called superclass-first. 
* Category +load methods are not called until after the parent class's +load.
* 
* This method must be RE-ENTRANT, because a +load could trigger 
* more image mapping. In addition, the superclass-first ordering 
* must be preserved in the face of re-entrant calls. Therefore, 
* only the OUTERMOST call of this function will do anything, and 
* that call will handle all loadable classes, even those generated 
* while it was running.
*
* The sequence below preserves +load ordering in the face of 
* image loading during a +load, and make sure that no 
* +load method is forgotten because it was added during 
* a +load call.
* Sequence:
* 1. Repeatedly call class +loads until there aren't any more
* 2. Call category +loads ONCE.
* 3. Run more +loads if:
*  (a) there are more classes to load, OR
*  (b) there are some potential category +loads that have 
*    still never been attempted.
* Category +loads are only run once to ensure "parent class first" 
* ordering, even if a category +load triggers a new loadable class 
* and a new loadable category attached to that class. 
*
* Locking: loadMethodLock must be held by the caller 
*   All other locks must not be held.
**********************************************************************/
void call_load_methods(void) {
  static bool loading = NO;
  bool more_categories; 
// 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;
}

initialize

  1. 惰性方法，第一次初始化实例对象的时候会调用这个方法
  2. 正常情况，只会调用一次
  3. 不正常情况，调用多次，多个子类没有实现 initialize，那么会多次调用父类的 initialize

分析 initialize

调用栈分析

1
2
3
4
5
6
7
0 +[XXObject initialize]
1 _class_initialize
2 lookUpImpOrForward
3 _class_lookupMethodAndLoadCache3
4 objc_msgSend
5 main
6 start
  1. 使用 oc 消息机制发送的
  2. 父类的initialize方法会比子类先执行
  3. 当子类未实现initialize方法时,会调用父类initialize方法,子类实现initialize方法时,会覆盖父类initialize方法. cls.isInitialized 判断该类是否被实例化过
  4. 当有多个Category都实现了initialize方法,会覆盖类中的方法,只执行一个

你真的了解 load 方法么？
懒惰的 initialize 方法