NSDictionary 内存布局
NSDictionary 内存布局
NSDictionary 内存布局
NSDictionary是iOS开发中经常用到的数据结构。
熟悉NSDictionary的内部实现，有助于我们更好的使用它们。
同时，在遇到相关崩溃，也能帮助我们更好的分析问题。
1 类簇
非可变字典由NSDictionary表示。
可变字典由NSMutableDictionary表示。
按照苹果官方文档的说法，NSDictionary和NSMutableDictionary都是类簇。
也就是说，NSDictionary和NSMutableDictionary只是暴露的公共接口，具体实现由内部众多私有子类完成。
2 类图
3 NSDictionary
下面介绍各个非可变字典的内存布局。
3.1 __NSDictionary0
__NSDictioanry0里面没有任何元素。
NSDictionary *dict = @{};
NSDictionary *dict = [NSdictionary dictionary];
上面代码都会创建一个__NSDictionary0。
(lldb) p dict
(__NSDictionary0 *) 0x00000001e3dd2390 0 key/value pairs
3.2 NSConstantDictionary
如果字典初始化时key-value对都是字符串常量，那么就会得到一个NSConstantDictionary。
NSDictionary *dict = @{
@"kaaa": @"aaa",
@"kbbb": @"bbb",
@"kccc": @"ccc",
@"kddd": @"ddd",
};
上面代码会创建一个NSConstantDictionary。
(lldb) p dict
(NSConstantDictionary *) 0x00000001021b87c8 4 key/value pairs
如果key不全是字符串，也不会得到NSConstantDictionary:
NSDictionary *dict = @{
@1: @"aaa",
@2: @"bbb",
@3: @"ccc",
@4: @"ddd",
};
上面代码会得到一个__NSDictionaryI:
(lldb) p dict
(__NSDictionaryI *) 0x0000600002c0af80 4 key/value pairs
3.2.1 内存布局
NSConstantDictionary的内存布局如下图所示:
isa指向对应的类对象。
options在调试时只遇到过值为1的情形，表示字典的key全是字符串。
当调用-[NSDictionary objectForKey:]方法时，如果参数不是字符串，不会处理:
-[NSConstantDictionary objectForKey:]:
...
// 1. x21 中存储方法参数
0x180430b60 <+120>: mov x0, x21
// 2. w23 存储的计时 options 的值
0x180430b64 <+124>: tbnz w23, #0x1, 0x180430b8c ; <+164>
// 3. 判断参数是否是字符串
0x180430b68 <+128>: bl 0x1804cf7ac ; _NSIsNSString
...
代码注释1，寄存器x21存储方法参数，传递给寄存器x0，作为下面函数_NSIsNSString的参数。
代码注释2，寄存器w23存储options的值，options为1，才会调用下面的函数_NSIsNSString方法。
代码注释3，调用_NSIsNSString方法对参数进行校验。
count存储字典中key-value的个数
keys是一个指针，指向字典中key所在的数组。
values是一个指针，指向字典中value所在的数组。
3.2.2 objectForKey:
使用objectForKey:方法读取一个key对应的value时:
1 使用二分法从keys数组中找到对应key所在的索引；
2 从values数组中根据索引返回对应的value值。
-[NSConstantDictionary objectForKey:]:
...
// 1. 调用二分法寻找参数在 keys 数组中的地址
0x180430c58 <+368>: bl 0x180547f18 ; symbol stub for: bsearch
0x180430c5c <+372>: cbz x0, 0x180430c6c ; <+388>
// 2. 计算参数在 keys 数组中的索引
0x180430c60 <+376>: sub x8, x0, x19
// 3. 获取 value 在 values 数组中地址
0x180430c64 <+380>: add x22, x22, x8
// 4. 获取 value 值
0x180430c68 <+384>: ldr x0, [x22]
...
代码注释1，调用二分法bsearch获取参数key在keys数组中所在地址，存储到x0。
代码注释2，x19指向keys数组首地址，这里计算出参数key在keys数组中的偏移量，也就是对应索引。
代码注释3，x22指向values数组首地址，这里计算出value在values数组中的地址。
代码注释4，从values数组中加载出value值，存储到x0。
3.3 __NSSingleEntryDictionaryI
如果字典中只有一个key-value对，就会得到__NSSingleEntryDictionaryI。
NSDictionary *dict = @{
@5: @"555",
};
上面代码会创建一个__NSSingleEntryDictionaryI:
(lldb) p dict
(__NSDictionaryI *) 0x0000600002c0af80 4 key/value pairs
但是，如果key是字符串，得到的还是NSConstantDictionary:
NSDictionary *dict = @{
@"5": @"555",
};
上面代码会创建一个NSConstantDictionary:
(lldb) p dict
(NSConstantDictionary *) 0x000000010445c7d8 1 key/value pair
3.3.1 内存布局
__NSSingleEntryDictionaryI的内存局部如下:
isa指向对应类对象。
key是一个指针，指向对应的key值
value是一个指针，指向对应的value值。
3.3.2 objectForKey:
__NSSingleEntryDictionaryI调用objectForKey:比较简单:
1 比较参数是否和存储的key值相等；
2 如果相等，就将存储的value返回。
3.4 __NSDictionaryI
大多数情况下，创建的NSDictionary对象，对应的类都是__NSDictionaryI。
3.4.1 初始化
通常我们会使用下面的函数初始化一个NSDictionary对象:
NSDictionary *dict = @{
@"kaaa": @"aaa",
@"kbbb": @"bbb",
@"kccc": @"ccc",
@"kddd": @"ddd",
};
NSDictionary *dictI = [NSDictionary dictionaryWithDictionary:dict];
上面函数会创建一个__NSDictionaryI对象:
(lldb) p dictI
(__NSDictionaryI *) 0x0000600002c07f80 4 key/value pairs
下面我们来看一下+[NSDictionary dictionaryWithDictionary:]方法的初始化过程。
CoreFoundation`+[NSDictionary dictionaryWithDictionary:]:
-> ...
0x1804b81a4 <+12>: mov x19, x2
// 1. 调用 objc_alloc 方法
0x1804b81a8 <+16>: bl 0x1805488cc ; symbol stub for: objc_alloc
0x1804b81ac <+20>: mov x2, x19
0x1804b81b0 <+24>: mov w3, #0x0 ; =0
// 2. 调用 initWithDictionary:copyItems: 方法
0x1804b81b4 <+28>: bl 0x180757aa0 ; objc_msgSend$initWithDictionary:copyItems:
...
代码注释1，调用objc_alloc为一个NSDictionary对象的内存空间。
代码注释2，调用initWithDictionary:copyItems:方法初始化第1步分配的内存空间。
但是当断点到initWithDictionary:copyItems:方法时，发现调用的是-[__NSPlaceholderDictionary initWithDictionary:compyItems:]方法，而不是期望的-[__NSDictionaryI initWithDictionary:copyItems:]方法。
CoreFoundation`-[__NSPlaceholderDictionary initWithDictionary:copyItems:]:
-> 0x180528b2c <+0>: sub sp, sp, #0x60
0x180528b30 <+4>: stp x24, x23, [sp, #0x20]
0x180528b34 <+8>: stp x22, x21, [sp, #0x30]
0x180528b38 <+12>: stp x20, x19, [sp, #0x40]
0x180528b3c <+16>: stp x29, x30, [sp, #0x50]
那就说明，方法objc_alloc分配了一个__NSPlaceholderDictionary对象。
从上面的类图可以知道，__NSPlaceholderDictionary继承自NSMutableDictionary。
非可变字典从可变字典初始化而来，出乎意料之外。
下面就来看下objc_alloc的实现。
objc_alloc函数源码位于objc4中的NSObject.mm文件中。
但是我们还是从汇编角度来看一下它的实现。
libobjc.A.dylib`objc_alloc:
...
// 1. 获取 isa 指针
0x1800917dc <+4>: ldr x8, [x0]
// 2. 掩码运算，剔除 isa 指针中的多余值
0x1800917e0 <+8>: and x8, x8, #0x7ffffffffffff8
// 3. 加载 AWZ 标志位
0x1800917e4 <+12>: ldrh w8, [x8, #0x1e]
// 4. 判断是否没有设置 AWZ 标志
0x1800917e8 <+16>: tbz w8, #0xe, 0x1800917f4 ; <+28>
// 5. 有 AWZ 标志位，就跳转执行 _objc_rootAllocWithZone 函数
0x1800917ec <+20>: b 0x180086eec ; _objc_rootAllocWithZone
0x1800917f0 <+24>: ret
0x1800917f4 <+28>: adrp x8, 482527
// 6. 如果没有设置了 AWZ 标志，执行 allocWithZone: 方法
0x1800917f8 <+32>: add x1, x8, #0x6e0
0x1800917fc <+36>: b 0x18006b400 ; objc_msgSend
代码注释1，获取isa指针。
由于我们调用objc_alloc传入的是NSDictionary.class对象，所以这里的isa指针指向NSDictionary.class的元类。
代码注释2，对isa指针做掩码运算，剔除不相干的位。
众所周知，iOS中的isa并不是所有的bit都是类对象指针，有些bit用作了其他用处。
iOS 12又引入了PAC指针验证机制，isa各个bit的使用有了变化。
下面是objc4源码中，对isa指针的最新定义:
// isa.h
...
# elif __has_feature(ptrauth_calls) || TARGET_OS_SIMULATOR
# define ISA_MASK 0x007ffffffffffff8ULL
# define ISA_MAGIC_MASK 0x0000000000000001ULL
# define ISA_MAGIC_VALUE 0x0000000000000001ULL
# define ISA_HAS_CXX_DTOR_BIT 0
# define ISA_BITFIELD
uintptr_t nonpointer : 1; // 此标志为 1，表明 isa 指针并不是纯粹的类指针
uintptr_t has_assoc : 1; // 是否有关联对象
uintptr_t weakly_referenced : 1; // 是否有弱引用
uintptr_t shiftcls_and_sig : 52; // 真正的类指针
uintptr_t has_sidetable_rc : 1; // 是否启用了 sidetable 来引用计数
uintptr_t extra_rc : 8 // 优先使用 8 bit 进行引用计数
从定义中可以看到，isa指针中，只有52bit用于真正的类指针。
因此，isa指针的掩码为0x7ffffffffffff8，刚好52个1。
代码注释3，加载NSDictionary的元类中的AWZ标志。
AWZ就是AllocWithZone的简写。
如果设置了AWZ标志，就说明这个类用默认的alloc或者allocWithZone:方法。
如果不设置AWZ标志，那就说明这个类对于alloc或者allocWithZone:方法有自己的实现。
我们可以看到在objc4源码中有对应的注释:
// objc-runtime-new.h
// class or superclass has default alloc/allocWithZone: implementation
// Note this is is stored in the metaclass.
# define FAST_CACHE_HAS_DEFAULT_AWZ (1<<14)
这个标志为0，说明该类自定义了alloc或者allocWithZone:方法。
那这个标志存在什么地方法呢？
从objc4源码可知，这个标志存在元类对象的flags属性中:
这个flags属性偏移元类对象首地址0x1e个字节。
代码注释4，判断是否没有设置AWZ标志。
从第3步介绍可知，AWZ标志设置在第14位，tbz指令查看flags的第14位是否为0。
代码注释5，如果设置了AWZ标志，那么使用使用默认的alloc或者allocWithZone:方法。
代码注释6，如果没有设置AWZ标志，那么就说明NSDictionary有自定义的alloc或者allocWithZone:方法。
x1寄存器存储着objc_msgsend要调用的方法名，打印可知，这个方法正是alloc:
(lldb) po (char *)$x1
"alloc"
最终，方法会调用到+[NSDictionary allocWithZone:]方法。
下面来看一下+[NSDictionary allocWithZone:]的实现。
CoreFoundation`+[NSDictionary allocWithZone:]:
...
0x1804b6d04 <+28>: adrp x8, 407836
0x1804b6d08 <+32>: ldr x8, [x8, #0x600]
// 1. 比较当前类对象是否是 NSDictionary
-> 0x1804b6d0c <+36>: cmp x8, x0
0x1804b6d10 <+40>: b.eq 0x1804b6d64 ; <+124>
0x1804b6d14 <+44>: adrp x8, 407836
0x1804b6d18 <+48>: ldr x8, [x8, #0x608]
// 2. 比较当前类对象是否是 NSMutableDictionary
0x1804b6d1c <+52>: cmp x8, x0
0x1804b6d20 <+56>: b.eq 0x1804b6d88 ; <+160>
...
// 3. 当前类是 NSDictionary，将执行 __NSDictionaryImmutablePlaceholder 方法
0x1804b6d84 <+156>: b 0x180528728 ; __NSDictionaryImmutablePlaceholder
...
// 4. 当前类是 NSMutableDictionary，将执行 __NSDictionaryMutablePlaceholder 方法
0x1804b6da8 <+192>: b 0x180528734 ; __NSDictionaryMutablePlaceholder
代码注释1，寄存器x8存储NSDictionary的类地址，寄存器x0存储当前类地址。
这里比较当前类地址是否是NSDictionary类。
如果比较成功，就会跳转执行__NSDictionaryImmutablePlaceholder 方法。
代码注释2，寄存器x8存储NSMutableDictionary的类地址。
这里比较当前类地址是否是NSMutableDictionary类。
如果比较成功，就会跳转执行__NSDictionaryMutablePlaceholder方法。
由于我们现在创建非可变字典，因此，代码最终会执行__NSDictionaryImmutablePlaceholder方法。
__NSDictionaryImmutablePlaceholder方法很简单，直接返回一个__NSPlaceholderDictionary对象:
CoreFoundation`__NSDictionaryImmutablePlaceholder:
0x180528728 <+0>: adrp x0, 407690
0x18052872c <+4>: add x0, x0, #0x338 ; ___immutablePlaceholderDictionary
-> 0x180528730 <+8>: ret
打印返回的对象:
(lldb) po [$x0 class]
__NSPlaceholderDictionary
顺便看一下__NSDictionaryMutablePlaceholder方法:
CoreFoundation`__NSDictionaryMutablePlaceholder:
0x180528734 <+0>: adrp x0, 407690
0x180528738 <+4>: add x0, x0, #0x348 ; ___mutablePlaceholderDictionary
-> 0x18052873c <+8>: ret
方法也很简单，也是直接返回一个__NSPlaceholderDictionary对象:
(lldb) po [$x0 class]
__NSPlaceholderDictionary
__NSPlaceholderDictionary对象的创建流程我们已经清楚了。
接下来，继续看-[__NSPlaceholderDictionary initWithDictionary:copyItems:]方法。
汇编代码不看了，直接上伪代码:
@interface __NSPlaceholderDictionary
...
@end
@implementation
- (instancetype)initWithDictionary:(NSDictionary *)dict copyItems:(BOOL)shouldCopy {
if (dict.class != __NSDictionaryI.class && dict.class != __NSDictionaryM.class && dict.class != __NSFrozenDictionaryM.class) {
return [super initWithDictionary:dict copyItems:shouldCopy];
}
if (self == ___mutablePlaceholderDictionary) {
return [dict mutableCopyWithZone:0];
}
if (self == ___immutablePlaceholderDictionary) {
return [dict copyWithZone:0];
}
}
@end
__NSDictionaryM和__NSFrozenDictionaryM在介绍可变字典时会涉及。
字典的拷贝在介绍完可变与非可变字典后会涉及。
由于本次例子中，我们使用的是一个NSConstantDictionary进行初始化，因此会调用到-[super initWithDictionary:copyItems:]方法。
__NSPlaceholderDictionary的super中，NSDictionary实现了这个方法。
-[NSDictionary initWithDictionary:copyItems:]不看汇编了，伪代码如下:
@interface NSDictionary
...
@end
@implementation
- (instancetype)initWithDictionary:(NSDictionary *)dict copyItems:(BOOL)shouldCopy {
NSInteger count = dict.count;
if （count >= 2^60) {
// 创建的字典 key-value 对不能超过 2^60
error "attempt to create a temporary id buffer which is too large or with a negative count (%lu) -- possibly data is corrupt"
}
NSObject *keys = nil;
NSObject *objects = nil;
if (count <= 0x100) {
// key-value 对数量 <= 256，在栈上分配空间
NSObject * keysArr[count];
NSObject * objectsArr[count];
keys = keysArr;
objects = objectsArr;
} else {
// key-value 对数量 > 256，在堆上分配空间
keys = _CFCreateArrayStorage(count, 0);
objects = _CFCreateArrayStorage(count, 0);
}
// 读取参数 dict 的 keys 和 objects 到分配的数组中
[dict getObjects:objects keys:keys count:count];
if (count != 0 && shouldCopy) {
// 拷贝 key-value 对
for (NSInteger i = 0; i < count; i++) {
NSObject *key = keys[i];
keys[i] = [key copyWithZone:nil];
}
for (NSInteger i = 0; i < count; i++) {
NSObject *object = objects[i];
objects[i] = [object copyWithZone:nil];
}
}
return [self initWithObjects:objects forKeys:keys count:count];
}
从上面伪代码可以看到，最终会调用NADictionary 的initWithObjects:forKeys:count:方法完成初始化。
initWithObjects:forKeys:count:正是NSDictionary的designated initializer方法。
下面就来看下这个方法。
由于此时的self真正的类型为__NSPlaceholderDictionary，所以此时真正调用的方法为-[__NSPlaceholderDictionary initWithObjects:forKeys:count:]。
下面我们就来看这个方法的伪代码:
// -[__NSPlaceholderDictionary initWithObjects:forKeys:count]
@interface __NSPlaceholderDictionary
...
@end
@implementation __NSPlaceholderDictionary
- (instancetype)initWithObjects:(ObjectType const[])objects forKeys:(ObjectTpye const[])keys count:(NSUInteger)count {
if (keys == nil && count == 0) {
goto label;
}
if (keys == nil && count != 0) {
// 报错
error "pointer to objects array is NULL but length is {count}";
}
if (keys != nil && count == 0 {
goto label;
}
if (keys != nil && count != 0) {
// 检测 keys 数组里的值是否有 nil
for (NSInteger i = 0; i < count; i++) {
ObjectType key = keys[i];
if (key == nil) {
// 报错
error "attempt to insert nil object from objects{[i]}";
}
}
}
if (objects == nil && count == 0) {
goto label;
}
if (objects == nil && count != 0) {
// 报错
error "pointer to objects array is NULL but length is {count}";
}
if (objects != nil && count == 0) {
goto label;
}
if (objects != nil && count != 0) {
// 检测 objects 数组里是否有 nil
for (NSInteger i = 0; i < count; i++) {
ObjectType object = objects[i];
if (object == nil) {
error "attempt to insert nil object from objects{[i]}";
}
}
}
label:
if (self == ___immutablePlaceholderDictionary) {
if (count == 0) {
// 创建 __NSDictionary0
return __NSDictionary0__();
}
if (count == 1) {
// 创建 __NSSingleEntryDictionaryI
return __NSSingleEntryDictionaryI_new(keys[0], objects[0], 1);
}
// 创建 __NSDictionaryI
return __NSDictionaryI_new(keys, objects, 0, count, 1);
} else if (self == ___mutablePlaceholderDictionary) {
// 创建 __NSDictionaryM
return __NSDictionaryM_new(keys, objecs, count, 3);
}
error "创建出错"
}
上面伪代码中，___immutablePlaceholderDictionary和___mutablePlaceholderDictionary在前面介绍alloc方法时提到过。
这里重点看下__NSDictionryI_news方法。
__NSDictionaryI_news内部首先根据count值，遍历一个全局数组__NSDictionaryCapacities。
__NSDictionaryCapacities总共有64项，每一项代表字典的capacity:
0x1803cc548 <+72>: adrp x8, 451
0x1803cc54c <+76>: add x8, x8, #0xc88 ; __NSDictionaryCapacities
在Xcode的lldb查看其内容为:
(lldb) x/64g $x8
0x18058fc88: 0x0000000000000000 0x0000000000000003
0x18058fc98: 0x0000000000000006 0x000000000000000b
0x18058fca8: 0x0000000000000013 0x0000000000000020
0x18058fcb8: 0x0000000000000034 0x0000000000000055
...
0x18058fe78: 0xc1d7fb9980000000 0xc2625e72e7800000
从上面的输出可以看到:
第0项的值为0；
第1项的值为3；
第63项的值为0xc2625e72e7800000，已经非常大了。
遍历__NSDictionaryCapacity数组的目的，是为了找到一个索引，这个索引对应的capacity大于或者等于count。
对应的伪代码为:
BOOL found = NO;
NSInteger index = 0;
for (; index < 64; index++) {
if (__NSDictionaryCapacity[i] >= count) {
found = YES;
break;
}
}
if (!found) {
error "不能创建 NSDictionary";
}
如果遍历了全部的64想，仍然没有满足条件的索引，那么程序就会crash。
需要注意的是，__NSDictionaryCapacity中存储的capacity，并不是要创建的字典的大小。
要创建的字典的大小，存储在全局变量__NSDictionarySizes中:
0x1803cc56c <+108>: adrp x8, 451
0x1803cc570 <+112>: add x8, x8, #0xb40 ; __NSDictionarySizes
在Xcode的lldb中查看其内容为:
(lldb) x/64g $x8
0x18058fb40: 0x0000000000000000 0x0000000000000003
0x18058fb50: 0x0000000000000007 0x000000000000000d
0x18058fb60: 0x0000000000000017 0x0000000000000029
0x18058fb70: 0x0000000000000047 0x000000000000007f
0x18058fb80: 0x00000000000000bf 0x00000000000000fb
...
从输出可以看到，除了第0项和第1项之外，其他各项的值与__NSDictionaryCapacity中的值都不相等。
通过上面遍历__NSDictionaryCapacity数组查找到的索引，就可以获取到要创建字典的大小:
NSUInteger size = __NSDictionarySizes[index];
按照道理，直接遍历__NSDictionarySizes也能达到效果。
至于为什么要分成2个数组__NSDictionaryCapacity和__NSDictionarySizes，暂时还不清楚原因。
有了要创建字典的大小，接下来就会创建对应的__NSDictionaryI对象:
___NSDictionaryI *dictI = __CFAllocateObject(__NSDictionaryI.class, size * 8 * 2);
上面代码中使用size * 8 * 2的原因是:
size代表key-value对的个数；
每一个key或者value占用8字节；
因此，一个key-value对占用16字节。
创建出的__NSDictionaryI对象，此时还没有存储任何的key-value对。
其内存布局此时为:
从内存布局可以看到，key-value对将直接存储在对象当中。
在存储key-value之前，还有一些其他属性需要存储在__NSDictionaryI对象中。
如上图所示:
第8字节的高6 bit存储这个字典对象size的索引，6 bit最多可以存储64项。
第8字节的第7 bit存储__NSDictionaryI._copyKey标志，但是现在暂时不知道它的作用。
第8字节剩余的57 bit存储实际的key-value对个数，初始值为count值。
这里有一个问题。
前面-[NSDictionary initWithDictionary:copyItems:]方法内部会对count值进行判断:
if （count >= 2^60) {
// 创建的字典 key-value 对不能超过 2^60
error "attempt to create a temporary id buffer which is too large or with a negative count (%lu) -- possibly data is corrupt"
}
可以看到，count的值最多可以占用60 bit。
但是这里只使用57 bit来存储count的值，不知道是不是Apple的BUG。
设置好这些属性，接下来就要遍历keys和objects数组，通过一个栈block给__NSDictionaryI对象填充key-value对:
for (NSInteger i = 0; i < count; i++) {
ObjectType key = keys[i];
ObjectTpye object = objects[i];
____NSDictionaryI_new_block_invoke(key, value);
}
____NSDictionaryI_new_block_invoke内部，首先对key调用hash函数获取器哈希值:
NSUInteger hashValue = [key hash];
计算出哈希值后，对字典的size进行取余，得到的结果作为__NSDictionaryI对象中，key-value对数组的索引:
NSUInteger index = hashValue % size;
__NSDictionaryI对象中的key-value对数组记作__NSDictionaryI._list。
有了index索引值，就可以从__NSDictionaryI._list数组中取出对应的值:
ObjectType oldKey = __NSDictionaryI._list[index];
如果oldKey为nil，说明这个位置之前没有值，那么当前的key-value对可以安全的存储到这个位置:
需要注意的是，写入的时对 key 进行了 copy。
[key copyWithZone:nil];
因此，字典中的key必须实现copy协议。
如果oldKey不为nil，说明这个位置已经被占用了，发生了hash冲突。
这时，需要分情形处理。
如果oldKey与key是同一个对象，或者他们的isEqual方法相等:
if (oldKey == key || [oldKey isEqual:key]) {
...
}
那么，当前的key-value对不会被写入，会被丢弃，同时__NSDictionaryI._used会减1。
如果oldKey与key不是同一个对象，同时，isEqual方法也不相等，那么就会从当前索引开始，遍历整个__NSDictionaryI._list数组。
如果遍历的过程中，找到了空位，那么就写入key-value对。
如果遍历的过程中，出现了上面oldKey与key相等的情形，那么就丢弃当前的key-value对，同时__NSDictionaryI._used减1。
由于字典的size总是大于或者等于count，因此不会出现遍历整个__NSDictionaryI._list数组，也找不到空位的情形。
3.4.2 内存布局
__NSDictionaryI对象完整的内存布局如下:
3.4.3 objectForKey:
-[__NSDictionaryI objectForKey:]方法首先调用参数key的hash方法:
NSUInteger hashValue = [key hash];
和初始化过程一样，获取哈希值目的是为了得到__NSDictionaryI._list数组中的索引:
NSUInteger index = hashValue % size;
那此时size是如何得到的呢？
上面__NSDictionaryI对象的内存布局可以知道，size的索引存储在第8字节上。
获取到这个值，就可以从__NSDictionarySizes数组中，取得size值。
获取到index之后，就可以从__NSDictionaryI._list数组中的值:
ObjectType candidateKey = __NSDictionaryI._list[index];
如果candidateKey为nil，说明这个位置根本没有值，那么直接返回nil。
如果candidateKey不为nil，那么就看candidateKey与参数key是否是同一个对象，或者两者的isEqual方法相等:
if (candidateKey == key || [candidateKey isEqual:key]) {
...
}
这种情况下，就是找到了目标key-value对，直接将对应的value值返回。
如果candidateKey与参数key既不是同一个对象，它们的isEqual方法也不相等，那么就从当前的index处开始遍历整个__NSDictionaryI._list数组。
这个过程和初始化过程有点类似:
遍历过程中，如果有candidateKey与参数key是同一个对象，或者isEqual方法相等，那么就找到了目标key-value对，直接返回value值。
如果遍历了整个数组，还是没有发现目标key-value对，就返回nil。
可以看到，如果哈希冲突比较严重，objectForKey:并不能O(1)时间返回目标值，可能需要O(size)的时间。