iOS - 老生常谈内存管理（六）：Tagged Pointer

在objc4源码中，咱们常常会在函数中看到Tagged Pointer。Tagged Pointer到底是何方神圣？请开始阅读本文。

1. Tagged Pointer 是什么？

如下是苹果在 WWDC2013 《Session 404 Advances in Objective-C》中对Tagged Pointer的介绍：
【视频连接：developer.apple.com/videos/play…，Tagged Pointer部分从 36:50 左右开始】

为了节省内存和提升执行效率，苹果在64bit程序中引入了Tagged Pointer技术，用于优化NSNumber、NSDate、NSString等小对象的存储。

在引入 Tagged Pointer 技术以前

NSNumber等对象存储在堆上，NSNumber的指针中存储的是堆中NSNumber对象的地址值。

从内存占用来看

基本数据类型所需的内存不大。好比NSInteger变量，它所占用的内存是与 CPU 的位数有关，以下。在 32 bit 下占用 4 个字节，而在 64 bit 下占用 8 个字节。指针类型的大小一般也是与 CPU 位数相关，一个指针所在 32 bit 下占用 4 个字节，在 64 bit 下占用 8 个字节。

#if __LP64__ || 0 || NS_BUILD_32_LIKE_64
typedef long NSInteger;
typedef unsigned long NSUInteger;
#else
typedef int NSInteger;
typedef unsigned int NSUInteger;
#endif
复制代码

假设咱们经过NSNumber对象存储一个NSInteger的值，系统实际上会给咱们分配多少内存呢？ 因为Tagged Pointer没法禁用，因此如下将变量i设了一个很大的数，以让NSNumber对象存储在堆上。

备注： 能够经过设置环境变量OBJC_DISABLE_TAGGED_POINTERS为YES来禁用Tagged Pointer，但若是你这么作，运行就Crash。

objc[39337]: tagged pointers are disabled
(lldb) 
复制代码

由于Runtime在程序运行时会判断Tagged Pointer是否被禁用，若是是的话就会调用_objc_fatal()函数杀死进程。因此，虽然苹果提供了OBJC_DISABLE_TAGGED_POINTERS这个环境变量给咱们，可是Tagged Pointer仍是没法禁用。

NSInteger i = 0xFFFFFFFFFFFFFF;
    NSNumber *number = [NSNumber numberWithInteger:i];
    NSLog(@"%zd", malloc_size((__bridge const void *)(number))); // 32
    NSLog(@"%zd", sizeof(number)); // 8
复制代码

因为NSNumber继承自NSObject，全部它有isa指针，加上内存对齐的处理，系统给NSNumber对象分配了 32 个字节内存。经过 LLDB 指令读取它的内存，实际上它并无用完 32 个字节。

从以上能够得知，在 64 bit 下，若是没有使用 Tagged Pointer的话，为了使用一个 NSNumber对象就须要 8 个字节指针内存和 32 个字节对象内存。而直接使用一个 NSInteger变量只要 8 个字节内存，相差好几倍。但总不能弃用 NSNumber对象而改用基本数据类型吧。

从效率上来看

为了使用一个NSNumber对象，须要在堆上为其分配内存，还要维护它的引用计数，管理它的生命周期，实在是影响执行效率。

在引入 Tagged Pointer 技术以后

NSNumber等对象的值直接存储在了指针中，没必要在堆上为其分配内存，节省了不少内存开销。在性能上，有着 3 倍空间效率的提高以及 106 倍建立和销毁速度的提高。

NSNumber等对象的指针中存储的数据变成了Tag+Data形式（Tag为特殊标记，用于区分NSNumber、NSDate、NSString等对象类型；Data为对象的值）。这样使用一个NSNumber对象只须要 8 个字节指针内存。当指针的 8 个字节不够存储数据时，才会在将对象存储在堆上。

咱们再来看一下若是使用了Tagged Pointer，系统会给NSNumber对象分配多少内存。

NSInteger i = 1;
     NSNumber *number = [NSNumber numberWithInteger:i];
     NSLog(@"%zd", malloc_size((__bridge const void *)(number))); // 0
     NSLog(@"%zd", sizeof(number)); // 8
复制代码

可见，使用了Tagged Pointer，NSNumber对象的值直接存储在了指针上，不会在堆上申请内存。则使用一个NSNumber对象只须要指针的 8 个字节内存就够了，大大的节省了内存占用。

2. Tagged Pointer 的原理

2.1 关闭 Tagged Pointer 的数据混淆

在如今的版本中，为了保证数据安全，苹果对 Tagged Pointer 作了数据混淆，开发者经过打印指针没法判断它是否是一个Tagged Pointer，更没法读取Tagged Pointer的存储数据。

因此在分析Tagged Pointer以前，咱们须要先关闭Tagged Pointer的数据混淆，以方便咱们调试程序。经过设置环境变量OBJC_DISABLE_TAG_OBFUSCATION为YES。

2.2 MacOS 分析

NSNumber

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSNumber *number1 = @1;
        NSNumber *number2 = @2;
        NSNumber *number3 = @3;
        NSNumber *number4 = @(0xFFFFFFFFFFFFFFFF);
    
        NSLog(@"%p %p %p %p", number1, number2, number3, number4);
    }
    return 0;
}
// 关闭 Tagged Pointer 数据混淆后：0x127 0x227 0x327 0x600003a090e0
// 关闭 Tagged Pointer 数据混淆前：0xaca2838a63a4fb34 0xaca2838a63a4fb04 0xaca2838a63a4fb14 0x600003a090e0
复制代码

从以上打印结果能够看出，number1～number3指针为Tagged Pointer类型，能够看到对象的值都存储在了指针中，对应0x1、0x2、0x3。而number4因为数据过大，指针的8个字节不够存储，因此在堆中分配了内存。

注意： MacOS与iOS平台下的Tagged Pointer有差异，下面会讲到。

0x127 中的 2 和 7 表示什么？

咱们先来看这个7，0x127为十六进制表示，7的二进制为0111。 最后一位1是Tagged Pointer标识位，表明这个指针是Tagged Pointer。 前面的011是类标识位，对应十进制为3，表示NSNumber类。

备注： MacOS下采用 LSB（Least Significant Bit，即最低有效位）为Tagged Pointer标识位，而iOS下则采用 MSB（Most Significant Bit，即最高有效位）为Tagged Pointer标识位。

能够在Runtime源码objc4中查看NSNumber、NSDate、NSString等类的标识位。

// objc-internal.h
{
    OBJC_TAG_NSAtom            = 0, 
    OBJC_TAG_1                 = 1, 
    OBJC_TAG_NSString          = 2, 
    OBJC_TAG_NSNumber          = 3, 
    OBJC_TAG_NSIndexPath       = 4, 
    OBJC_TAG_NSManagedObjectID = 5, 
    OBJC_TAG_NSDate            = 6,
    ......
}
复制代码

代码验证：

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSNumber *number = @1;
        NSString *string = [NSString stringWithFormat:@"a"];
    
        NSLog(@"%p %p", number, string);
    }
    return 0;
}
// 0x127 0x6115
复制代码

以上打印的string指针值为0x6115，61是a的 ASCII 码，最后一位5的二进制为0101，其中最后一位1是表明这个指针是Tagged Pointer前面已经说过，010对应十进制为2，表示NSString类。

0x127 中的 2（即倒数第二位）又表明什么呢？

倒数第二位用来表示数据类型。

示例：

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        char a = 1;
        short b = 1;
        int c = 1;
        long d = 1;
        float e = 1.0;
        double f = 1.00;
        
        NSNumber *number1 = @(a);
        NSNumber *number2 = @(b);
        NSNumber *number3 = @(c);
        NSNumber *number4 = @(d);
        NSNumber *number5 = @(e);
        NSNumber *number6 = @(f);

        NSLog(@"%p %p %p %p %p %p", number1, number2, number3, number4, number5, number6);
    }
    return 0;
}
// 0x107 0x117 0x127 0x137 0x147 0x157
复制代码

Tagged Pointer倒数第二位对应数据类型：

Tagged Pointer 倒数第二位	对应数据类型
0	char
1	short
2	int
3	long
4	float
5	double

下图是MacOS下NSNumber的Tagged Pointer位视图：

NSString

接下来咱们来分析一下Tagged Pointer在NSString中的应用。同NSNumber同样，在64 bit的MacOS下，若是一个NSString对象指针为Tagged Pointer，那么它的后 4 位（0-3）做为标识位，第 4-7 位表示字符串长度，剩余的 56 位就能够用来存储字符串。

示例：

// MRC 环境
#define HTLog(_var) \
{ \
    NSString *name = @#_var; \
    NSLog(@"%@: %p, %@, %lu", name, _var, [_var class], [_var retainCount]); \
}

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSString *a = @"a";
        NSMutableString *b = [a mutableCopy];
        NSString *c = [a copy];
        NSString *d = [[a mutableCopy] copy];
        NSString *e = [NSString stringWithString:a];
        NSString *f = [NSString stringWithFormat:@"f"];
        NSString *string1 = [NSString stringWithFormat:@"abcdefg"];
        NSString *string2 = [NSString stringWithFormat:@"abcdefghi"];
        NSString *string3 = [NSString stringWithFormat:@"abcdefghij"];
        HTLog(a);
        HTLog(b);
        HTLog(c);
        HTLog(d);
        HTLog(e);
        HTLog(f);
        HTLog(string1);
        HTLog(string2);
        HTLog(string3);
    }
    return 0;
}
/* a: 0x100002038, __NSCFConstantString, 18446744073709551615 b: 0x10071f3c0, __NSCFString, 1 c: 0x100002038, __NSCFConstantString, 18446744073709551615 d: 0x6115, NSTaggedPointerString, 18446744073709551615 e: 0x100002038, __NSCFConstantString, 18446744073709551615 f: 0x6615, NSTaggedPointerString, 18446744073709551615 string1: 0x6766656463626175, NSTaggedPointerString, 18446744073709551615 string2: 0x880e28045a54195, NSTaggedPointerString, 18446744073709551615 string3: 0x10071f6d0, __NSCFString, 1 */
复制代码

从打印结果来看，有三种NSString类型：

类型	描述
__NSCFConstantString	1. 常量字符串，存储在字符串常量区，继承于 __NSCFString。相同内容的 __NSCFConstantString 对象的地址相同，也就是说常量字符串对象是一种单例，能够经过 == 判断字符串内容是否相同。 2. 这种对象通常经过字面值@"..."建立。若是使用 __NSCFConstantString 来初始化一个字符串，那么这个字符串也是相同的 __NSCFConstantString。
__NSCFString	1. 存储在堆区，须要维护其引用计数，继承于 NSMutableString。 2. 经过stringWithFormat:等方法建立的NSString对象（且字符串值过大没法使用Tagged Pointer存储）通常都是这种类型。
NSTaggedPointerString	Tagged Pointer，字符串的值直接存储在了指针上。

打印结果分析：

NSString 对象	类型	分析
a	__NSCFConstantString	经过字面量@"..."建立
b	__NSCFString	a 的深拷贝，指向不一样的内存地址，被拷贝到堆区
c	__NSCFConstantString	a 的浅拷贝，指向同一块内存地址
d	NSTaggedPointerString	单独对 a 进行 copy（如 c），浅拷贝是指向同一块内存地址，因此不会产生Tagged Pointer；单独对 a 进行 mutableCopy（如 b），复制出来是可变对象，内容大小能够扩展；而Tagged Pointer存储的内容大小有限，所以没法知足可变对象的存储要求。
e	__NSCFConstantString	使用 __NSCFConstantString 来初始化的字符串
f	NSTaggedPointerString	经过stringWithFormat:方法建立，指针足够存储字符串的值。
string1	NSTaggedPointerString	经过stringWithFormat:方法建立，指针足够存储字符串的值。
string2	NSTaggedPointerString	经过stringWithFormat:方法建立，指针足够存储字符串的值。
string3	__NSCFString	经过stringWithFormat:方法建立，指针不足够存储字符串的值。

能够看到，为Tagged Pointer的有d、f、string1、string2指针。它们的指针值分别为 0x6115、0x6615、0x6766656463626175、0x880e28045a54195。

其中0x61、0x66、0x67666564636261分别对应字符串的 ASCII 码。

最后一位5的二进制为0101，最后一位1是表明这个指针是Tagged Pointer，010对应十进制为2，表示NSString类。

倒数第二位1、1、7、9表明字符串长度。

对于string2的指针值0x880e28045a54195，虽然从指针中看不出来字符串的值，但其也是一个Tagged Pointer。

下图是MacOS下NSString的Tagged Pointer位视图：

2.3 iOS 分析

NSNumber

- (void)viewDidLoad {
    [super viewDidLoad];
               
    NSNumber *number1 = @1;
    NSNumber *number2 = @2;
    NSNumber *number3 = @79;
    NSNumber *number4 = @(0xFFFFFFFFFFFFFFFF);
    
    NSLog(@"%p %p %p %p", number1, number2, number3, number4);   
}
// 0xb000000000000012 0xb000000000000022 0xb0000000000004f2 0x600000678480
复制代码

从以上打印结果能够看出，number1～number3指针为Tagged Pointer类型，能够看到对象的值都存储在了指针中，对应倒数第二位开始的1、2、4f。而number4因为数据过大，指针的8个字节不够存储，因此在堆中分配了内存。

最后一位用来表示数据类型。

第一位b的二进制为1011，其中第一位1是Tagged Pointer标识位。后面的011是类标识位，对应十进制为3，表示NSNumber类。

下图是iOS下NSNumber的Tagged Pointer位视图：

NSString

同理，再也不分析。

下图是iOS下NSString的Tagged Pointer位视图：

3. 如何判断 Tagged Pointer ？

前面已经说过了，经过Tagged Pointer标识位。

在objc4源码中找到判断Tagged Pointer的函数：

// objc-internal.h
static inline bool 
_objc_isTaggedPointer(const void * _Nullable ptr)
{
    return ((uintptr_t)ptr & _OBJC_TAG_MASK) == _OBJC_TAG_MASK;
}
复制代码

能够看到，它是将指针值与一个_OBJC_TAG_MASK掩码进行按位与运算，查看该掩码：

#if (TARGET_OS_OSX || TARGET_OS_IOSMAC) && __x86_64__
    // 64-bit Mac - tag bit is LSB
# define OBJC_MSB_TAGGED_POINTERS 0 // MacOS
#else
    // Everything else - tag bit is MSB
# define OBJC_MSB_TAGGED_POINTERS 1 // iOS
#endif

#define _OBJC_TAG_INDEX_MASK 0x7
// array slot includes the tag bit itself
#define _OBJC_TAG_SLOT_COUNT 16
#define _OBJC_TAG_SLOT_MASK 0xf

#define _OBJC_TAG_EXT_INDEX_MASK 0xff
// array slot has no extra bits
#define _OBJC_TAG_EXT_SLOT_COUNT 256
#define _OBJC_TAG_EXT_SLOT_MASK 0xff

#if OBJC_MSB_TAGGED_POINTERS
# define _OBJC_TAG_MASK (1UL<<63) // _OBJC_TAG_MASK # define _OBJC_TAG_INDEX_SHIFT 60 # define _OBJC_TAG_SLOT_SHIFT 60 # define _OBJC_TAG_PAYLOAD_LSHIFT 4 # define _OBJC_TAG_PAYLOAD_RSHIFT 4 # define _OBJC_TAG_EXT_MASK (0xfUL<<60) # define _OBJC_TAG_EXT_INDEX_SHIFT 52 # define _OBJC_TAG_EXT_SLOT_SHIFT 52 # define _OBJC_TAG_EXT_PAYLOAD_LSHIFT 12 # define _OBJC_TAG_EXT_PAYLOAD_RSHIFT 12 #else # define _OBJC_TAG_MASK 1UL // _OBJC_TAG_MASK # define _OBJC_TAG_INDEX_SHIFT 1 # define _OBJC_TAG_SLOT_SHIFT 0 # define _OBJC_TAG_PAYLOAD_LSHIFT 0 # define _OBJC_TAG_PAYLOAD_RSHIFT 4 # define _OBJC_TAG_EXT_MASK 0xfUL # define _OBJC_TAG_EXT_INDEX_SHIFT 4 # define _OBJC_TAG_EXT_SLOT_SHIFT 4 # define _OBJC_TAG_EXT_PAYLOAD_LSHIFT 0 # define _OBJC_TAG_EXT_PAYLOAD_RSHIFT 12 #endif 复制代码

由此咱们能够验证：

• MacOS下采用 LSB（Least Significant Bit，即最低有效位）为Tagged Pointer标识位；
• iOS下则采用 MSB（Most Significant Bit，即最高有效位）为Tagged Pointer标识位。

而存储在堆空间的对象因为内存对齐，它的内存地址的最低有效位为 0。由此能够辨别Tagged Pointer和通常对象指针。

在objc4源码中，咱们常常会在函数中看到Tagged Pointer。好比objc_msgSend函数：

ENTRY _objc_msgSend
	UNWIND _objc_msgSend, NoFrame

	cmp	p0, #0 // nil check and tagged pointer check
#if SUPPORT_TAGGED_POINTERS
	b.le	LNilOrTagged		// (MSB tagged pointer looks negative)
#else
	b.eq	LReturnZero
#endif
	ldr	p13, [x0]		// p13 = isa
	GetClassFromIsa_p16 p13		// p16 = class
LGetIsaDone:
	// calls imp or objc_msgSend_uncached
	CacheLookup NORMAL, _objc_msgSend

#if SUPPORT_TAGGED_POINTERS
LNilOrTagged:
	b.eq	LReturnZero		// nil check

	// tagged
	adrp	x10, _objc_debug_taggedpointer_classes@PAGE
	add	x10, x10, _objc_debug_taggedpointer_classes@PAGEOFF
	ubfx	x11, x0, #60, #4
	ldr	x16, [x10, x11, LSL #3]
	adrp	x10, _OBJC_CLASS_$___NSUnrecognizedTaggedPointer@PAGE
	add	x10, x10, _OBJC_CLASS_$___NSUnrecognizedTaggedPointer@PAGEOFF
	cmp	x10, x16
	b.ne	LGetIsaDone

	// ext tagged
	adrp	x10, _objc_debug_taggedpointer_ext_classes@PAGE
	add	x10, x10, _objc_debug_taggedpointer_ext_classes@PAGEOFF
	ubfx	x11, x0, #52, #8
	ldr	x16, [x10, x11, LSL #3]
	b	LGetIsaDone
// SUPPORT_TAGGED_POINTERS
#endif
复制代码

objc_msgSend能识别Tagged Pointer，好比NSNumber的intValue方法，直接从指针提取数据，不会进行objc_msgSend的三大流程，节省了调用开销。

内存管理相关的，如retain方法中调用的rootRetain：

ALWAYS_INLINE id 
objc_object::rootRetain(bool tryRetain, bool handleOverflow)
{
    // 若是是 tagged pointer，直接返回 this
    if (isTaggedPointer()) return (id)this; 

    bool sideTableLocked = false;
    bool transcribeToSideTable = false; 

    isa_t oldisa;
    isa_t newisa;
    ......
复制代码

来看一下isTaggedPointer()函数实现：

inline bool 
objc_object::isTaggedPointer() 
{
    return _objc_isTaggedPointer(this);
}
复制代码

该函数就是调用了_objc_isTaggedPointer。

4. Tagged Pointer 注意点

咱们知道，全部OC对象都有isa指针，而Tagged Pointer并非真正的对象，它没有isa指针，因此若是你直接访问Tagged Pointer的isa成员的话，在编译时将会有以下警告：

对于Tagged Pointer，应该换成相应的方法调用，如isKindOfClass和object_getClass。只要避免在代码中直接访问Tagged Pointer的isa，便可避免这个问题。

固然如今也不容许咱们在代码中直接访问对象的isa了，不然编译不经过。

咱们经过 LLDB 打印Tagged Pointer的isa，会提示以下错误：

而打印OC对象的isa没有问题：

相关题目

Q：执行如下两段代码，有什么区别？

dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    for (int i = 0; i < 1000; i++) {
        dispatch_async(queue, ^{
            self.name = [NSString stringWithFormat:@"abcdefghij"];
        });
    }
复制代码

dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    for (int i = 0; i < 1000; i++) {
        dispatch_async(queue, ^{
            self.name = [NSString stringWithFormat:@"abcdefghi"];
        });
    }
复制代码

内心一万个草泥马🦙奔腾而过～～～，两段代码差异不就是字符串长度少了一位吗，哪有什么差异？

结果一运行，哎呀？第一段代码竟然Crash，而第二段却没有问题，奇了怪了。 分别打印两段代码的self.name类型看看，原来第一段代码中self.name为__NSCFString类型，而第二段代码中为NSTaggedPointerString类型。

咱们来看一下第一段代码Crash的地方：

想必你已经猜到了，__NSCFString存储在堆上，它是个正常对象，须要维护引用计数的。self.name经过setter方法为其赋值。而setter方法的实现以下：

- (void)setName:(NSString *)name {
    if(_name != name) {
        [_name release];
        _name = [name retain]; // or [name copy]
    }
}
复制代码

咱们异步并发执行setter方法，可能就会有多条线程同时执行[_name release]，连续release两次就会形成对象的过分释放，致使Crash。

解决办法：

• 1. 使用atomic属性关键字。
• 2. 加锁

dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    for (int i = 0; i < 1000; i++) {
        dispatch_async(queue, ^{
            // 加锁
            self.name = [NSString stringWithFormat:@"abcdefghij"];
            // 解锁
        });
    }
复制代码

而第二段代码中为NSTaggedPointerString类型，就意味着它不会去调用setter方法，而是直接将Tagged Pointer指针的值赋值给成员变量，因此能够正常运行。