你不知道的TaggedPointer

一、环境介绍

  1. mac版本：Mac Mojave 10.14
  2. objc版本：objc runtime 750

二、为什么要使用TaggedPointer？

以前我们初始化一个对象（64位为例），开发的代码如下

1
NSNumber *number2 = [NSNumber numberWithInteger:2];

此时的内存图如下

15469379882496.jpg

可以看到我就想存一个2用掉了24个字节，由于我们的NSNumber和NSDate对象的值一般不需要8个字节，4个字节的长度2^31=2147483648可以表达的数量已经达到了20多亿了，为了不造成内存的浪费，想到将指针的值(8个字节)进行拆分，一部分表示数据，一部分用来表示是一个特殊的指针，他不执行任何对象，这就是TaggedPointer技术，这样指针 = Data + Tag，那么我们的存一个数字只需要8个字节就够了。

三、一个简单的例子

3.1 版本新特性

1
2
3
4
5
6
7
8
9
NSNumber *number1 = @1;
NSNumber *number2 = @2;
NSNumber *number3 = @3;
NSNumber *numberFFFF = @(0xFFFF);

NSLog(@"number1 pointer is %p", number1);
NSLog(@"number2 pointer is %p", number2);
NSLog(@"number3 pointer is %p", number3);
NSLog(@"numberffff pointer is %p", numberFFFF);

输出结果却是这个样子的

1
2
3
4
number1 pointer is 0x19ec25e574ba1459
number2 pointer is 0x19ec25e574ba1759
number3 pointer is 0x19ec25e574ba1659
numberffff pointer is 0x19ec25e57445ea59

这个地址有点特殊，研究了一下，发现原来是在10_14以后苹果对TaggedPointer进行了混淆，文件objc-runtime-new.m写到

1
2
3
4
5
6
7
8
9
10
11
12
static void
initializeTaggedPointerObfuscator(void)
{
    if (sdkIsOlderThan(10_14, 12_0, 12_0, 5_0, 3_0) ||
        DisableTaggedPointerObfuscation) {
        objc_debug_taggedpointer_obfuscator = 0;
    } else {
        arc4random_buf(&objc_debug_taggedpointer_obfuscator,
                       sizeof(objc_debug_taggedpointer_obfuscator));
        objc_debug_taggedpointer_obfuscator &= ~_OBJC_TAG_MASK;
    }
}

混淆的代码也很简单，类似这种加入加密前的数据是a,加密后的数据为b，
那么：

加密：b = a ^ objc_debug_taggedpointer_obfuscator,
解密: a = b ^ objc_debug_taggedpointer_obfuscator.

这里利用了异或的特性，源码如下：

1
2
3
4
5
6
7
8
9
10
11
static inline void * _Nonnull
_objc_encodeTaggedPointer(uintptr_t ptr)
{
    return (void *)(objc_debug_taggedpointer_obfuscator ^ ptr);
}

static inline uintptr_t
_objc_decodeTaggedPointer(const void * _Nullable ptr)
{
    return (uintptr_t)ptr ^ objc_debug_taggedpointer_obfuscator;
}

所以要想知道0x19ec25e574ba1459是什么意思，还是要知道objc_debug_taggedpointer_obfuscator值，这是个随机值，要想获取这个值：

方法一：通过断点来获取

15471013678173.jpg

通过lldb指令读取

1
2
(lldb) p/x objc_debug_taggedpointer_obfuscator
(uintptr_t) $0 = 0x19ec25e574ba157e

方法二： 看来runtime源码知道objc_debug_taggedpointer_obfuscator是个全局变量，只要在我们用的地方申明一下即可

1
extern uintptr_t objc_debug_taggedpointer_obfuscator;

通过NSLog打印就可以了

1
NSLog(@"%lx",objc_debug_taggedpointer_obfuscator);

为了方便查看，简单写了一个方法，用来解开混淆

1
2
3
4
uintptr_t _objc_decodeTaggedPointer_(id  ptr) {
    NSString *p = [NSString stringWithFormat:@"%ld",ptr];
    return [p longLongValue] ^ objc_debug_taggedpointer_obfuscator;
}

3.2 真实的地址

1
2
3
4
5
6
7
8
9
NSNumber *number1 = @1;
NSNumber *number2 = @2;
NSNumber *number3 = @3;
NSNumber *numberFFFF = @(0xFFFF);

NSLog(@"number1 pointer is %p---真实地址:==0x%lx", number1,_objc_decodeTaggedPointer_(number1));
NSLog(@"number2 pointer is %p---真实地址:==0x%lx", number2,_objc_decodeTaggedPointer_(number2));
NSLog(@"number3 pointer is %p---真实地址:==0x%lx", number3,_objc_decodeTaggedPointer_(number3));
NSLog(@"numberffff pointer is %p---真实地址:==0x%lx", numberFFFF,_objc_decodeTaggedPointer_(numberFFFF));

输出

1
2
3
4
number1 pointer is 0xfda27e12be89be71---真实地址:==0x127
number2 pointer is 0xfda27e12be89bd71---真实地址:==0x227
number3 pointer is 0xfda27e12be89bc71---真实地址:==0x327
numberffff pointer is 0xfda27e12be764071---真实地址:==0xffff27

会发现，不管运行多少次，都是以27结尾，我们有理由相信，苹果贡献了1个字节（8个bit）来标识这是个特殊的指针，最后1个字节用来标识，这个类指针，判断是否是TaggedPointer不同平台判断的方式不一样，但对我们理解根本不影响

1
2
3
4
5
static inline bool 
_objc_isTaggedPointer(const void * _Nullable ptr)
{
    return ((uintptr_t)ptr & _OBJC_TAG_MASK) == _OBJC_TAG_MASK;
}
  1. mac平台最后一个为1；
  2. iPhone和模拟器，为最高位是1。

那么剩下的7个字节是不是都用来存放数据呢？

3.3 TaggedPointer存储的数字的最大值

1
2
3
4
5
6
7
8
9
10
11
12
NSNumber *numberF13   = @(0xFFFFFFFFFFFFF);
NSNumber *numberF13_1 = @(0x1FFFFFFFFFFFFF);
NSNumber *numberF13_3 = @(0x3FFFFFFFFFFFFF);
NSNumber *numberF13_7 = @(0x7FFFFFFFFFFFFF);
NSNumber *numberF14   = @(0xFFFFFFFFFFFFFF);

NSLog(@"numberF13 pointer is %p---真实地址:==0x%lx", numberF13,_objc_decodeTaggedPointer_(numberF13));
NSLog(@"numberF13_1 pointer is %p---真实地址:==0x%lx", numberF13_1,_objc_decodeTaggedPointer_(numberF13_1));
NSLog(@"numberF13_3 pointer is %p---真实地址:==0x%lx", numberF13_3,_objc_decodeTaggedPointer_(numberF13_3));
NSLog(@"numberF13_7 pointer is %p---真实地址:==0x%lx", numberF13_7,_objc_decodeTaggedPointer_(numberF13_7));
   
NSLog(@"numberF14 pointer is %p---真实地址:==0x%lx", numberF14,_objc_decodeTaggedPointer_(numberF14));

输出如下

1
2
3
4
5
6
7
8
9
10
number1 pointer is 0x20f9850034a2e631---真实地址:==0x127
number2 pointer is 0x20f9850034a2e531---真实地址:==0x227
number3 pointer is 0x20f9850034a2e431---真实地址:==0x327
numberffff pointer is 0x20f98500345d1831---真实地址:==0xffff27
numberF13 pointer is 0x2f067affcb5d1821---真实地址:==0xfffffffffffff37
numberF13_1 pointer is 0x3f067affcb5d1821---真实地址:==0x1fffffffffffff37
numberF13_3 pointer is 0x1f067affcb5d1821---真实地址:==0x3fffffffffffff37
numberF13_7 pointer is 0x5f067affcb5d1821---真实地址:==0x7fffffffffffff37

numberF14 pointer is 0x102500210

从输出可以看出，到numberF14地址已经是真正的oc对象的地址了，说明有效存储位置有56位，所以TaggedPointer所能表达的数字范围为[0 2^65)。

四、思考：你会如何实现NSString的TaggedPointer？

我们现在想做的事情就是如何利用指针来存储我们的字符数据，而指针的大小就是8个字节，一共64位，如何利用这个64位呢？由NSNumber的灵感，可以使用低1位来表示是TaggedPointer类型，其他三位来表示具体哪个类的，对于字符串，需要存储它的长度，再让出4位，还剩下56位，从而问题转为如何利用这个56位。

计算机中存储的就是0和1，对于字符串的编码有ASCII和非ASCII：

  1. ASCII是利用一个字节的大小表示字符的，一共是128个（最高位都为0）；
  2. 后面为了统一编码出现了Unicode编码，Unicode是规定了符号的二进制代码，没有规定如何存储，具体如何存储的，后来就出现了，UTF-16（字符用两个字节或四个字节表示）、UTF-32（字符用四个字节表示）和UTF-8（最常用的，兼容了ASCII）

对于非ASCII：

  1. 如果是UTF-32编码的,要想包含所有Unicode，需要4个字节，那么最多也只能保存1个字符，没有任何意义；
  2. 如果是 UTF-16编码的，要想包含所有Unicode，也需要4个字节，最少也需要2个字节，按最少的算，那么56位，也只能放3个16为的字符，还是很少；
  3. 如果是UTF-8，如果撇开ASCII的话，那么也是最多需要4个字节，最少2个字节，56位还是最多放3个字节。

对于非ASCII我们貌似没有找到一个好的方案来存储，那么我们要实现TaggedPointer的话，是不是可以不考虑非ASCII的情况，毕竟在实际场景，我们用到ASCII的场景的几率还是比非ASCII大的多，对于非ASCII的还是交给开辟控件的方式。

对于ASCII:

如果我们不考虑非ASCII的话，那么有以下方案可以用来存储数据：

  1. 方案一: 使用8位存储一个字符，这也是默认计算机存储ASCII的方式，由于占用一个字节，那么这种方式56位可以放7个字节；
  2. 方案二: 使用7位存储一个字符，ASCII其实真正存储数据的是7位，如果是用7位表示一个字符的话，那么最多可以放8个字节，比方案一多出一个字节；
  3. 方案三: 使用6位存储，有人可能想6位怎么可能，存储ASCII最少也得7位啊，6怎么存储，是的，直接存是不行的，但是我们可以不直接存字符，而是提供一个表格，存索引。ASCII一共有128个，但是我们常用的根本就没有那么多，那么我们可以不可以选出一些常用的来作为我们的可选值 ？ 6位的话，最多可以存储2^ 6 = 64个不同的字符,所以肯定是不能满查找ASCII集合，但是，我们可以找来常见的64个字符比如[a-zA-z0-9./_-],这里就有66个了，再从这个66个里面取出2个不常用的就可以了，这样的话我们就可以存储9个字节了；
  4. 方案四: 使用5位存储，这种的话我们的查找范围就缩小为了2^5 = 32个，也就是我们要在方案三的基础上在找出更加常用的32个字符，这种方案可以存储11个字符；
  5. 方案五: 使用4位存储，那范围就是2^4 = 16个，这种感觉行也行，但是范围太小了
  6. 更少的想想不大可能了

下面看下苹果是如何实现的

五、对于NSString苹果是如何使用TaggedPointer的？

5.1 现象

添加测试如下测试代码

1
2
3
4
5
6
7
8
NSMutableString *imutable = [NSMutableString string];
NSString *immutable;
char c = 'a';
do {
 [imutable appendFormat: @"%c", c++];
 immutable = [imutable copy];
 NSLog(@"源地址：%p 真实地址：0x%lx %@ %@", immutable,_objc_decodeTaggedPointer_(immutable), immutable, object_getClass(immutable));
} while(((uintptr_t)immutable & 1) == 1);

输出，这里我省去了源地址，因为这里打印了类的类型更直观写

1
2
3
4
5
6
7
8
9
10
真实地址：0x6115                 a               NSTaggedPointerString
真实地址：0x626125               ab              NSTaggedPointerString
真实地址：0x63626135             abc             NSTaggedPointerString
真实地址：0x6463626145           abcd            NSTaggedPointerString
真实地址：0x656463626155         abcde           NSTaggedPointerString
真实地址：0x66656463626165       abcdef          NSTaggedPointerString
真实地址：0x6766656463626175     abcdefg         NSTaggedPointerString
真实地址：0x22038a01169585       abcdefgh        NSTaggedPointerString
真实地址：0x880e28045a54195      abcdefghi       NSTaggedPointerString
真实地址：0xf9eb5f3ca3c376e0     abcdefghij      __NSCFString

前面提到过最后一个字节低4位标志是TaggedPointer信息，高4位存放字符串的长度，所以最后一个数字5是标志位，倒数一个数字就是字符串的长度。

从上面的输出可以看出：

  1. 当字符串的长度<=7的时候，苹果是直接存储的字符ASCII值，a的ASCII值是61，b是62…。
  2. 当字符串长度大于7的时候具体如何做的，我们通过逆向CoreFoundation.framework来查看

5.2 hopper -> length

先来看下length方法，看看是不是和我们猜测的一样

15471101516030.jpg

翻译一下就是

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

rdi = self ^ *_objc_debug_taggedpointer_obfuscator; // 解密得到真实地址

if ((di & 14 ) == 14) { 也就是//0b1110 我们的字符串的是5(0x0101)，所以走else了
       rax = (di >> 11) & 0xf;
} else {
       rax =(di >>  4 ) & 0xf;
}  


再简化一下就是

======

rax = (di >>  4 ) & 0xf

已经很显然了，就是拿低1字节的高4位的值,证明了我们的猜想。

5.3 hopper -> characterAtIndex

苹果是如何将字符转成NSTaggedPointerString的，不是很好查，但是我们可以反向思考，通过取数据来反推如何存的，

15471113839214.jpg

下面开始简化该伪代码，如果你觉得不想看，可以直接跳到第四次简化开始看。

___stack_chk_guard是为了安全加的，不考虑，前面分析过((((r8 ^ rdi) & 0xe) == 0xe ? 0x1 : 0x0) << 0x3 | 0x4)在这里等价于0x4，arg2就是传进来的index

5.3.1 第一次简化

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
unsigned short -[NSTaggedPointerString characterAtIndex:](void * self, void * _cmd, unsigned long long arg2) {
    r12 = index;
    rbx = self >>  0x4 & 0xf;
    r8 = self >> 0x4 >> 0x4;
    if (rbx >= 0x8) {
            rdx = rbx;
            if (rbx < 0xa) {
                    do {
                            *(int8_t *)(rbp + rdx + 0xffffffffffffffc7) = *(int8_t *)((r8 & 0x3f) + _sixBitToCharLookup);
                            rdx = rdx - 0x1;
                            r8 = r8 >> 0x6;
                    } while (rdx != 0x0);
            }
            else {
                    do {
                            *(int8_t *)(rbp + rdx + 0xffffffffffffffc7) = *(int8_t *)((r8 & 0x1f) + _sixBitToCharLookup);
                            rdx = rdx - 0x1;
                            r8 = r8 >> 0x5;
                    } while (rdx != 0x0);
            }
    }

    rax = *(int8_t *)(rbp + r12 + 0xffffffffffffffc8) & 0xff;
    
    return rax;
}

继续分析这段代码

  1. self >> 0x4 & 0xf;其实就是字符串的length
  2. self >> 0x4 >> 0x4;其实就是字符串的开始位置
  3. 0xffffffffffffffc7其实是-0x39 = -57的补码,0xffffffffffffffc7是-0x38 = -56的补码

5.3.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
unsigned short -[NSTaggedPointerString characterAtIndex:](void * self, void * _cmd, unsigned long long arg2) {
    rbx = length;
    r8 = self >> 0x8;
    if (rbx >= 0x8) {
            if (length < 0xa) {
                    do {
                            *(int8_t *)(rbp - 57 + rdx) = *(int8_t *)((r8 & 0x3f) + _sixBitToCharLookup);
                            rdx = rdx - 0x1;
                            r8 = r8 >> 0x6;
                    } while (rdx != 0x0);
            }
            else {
                    do {
                            *(int8_t *)(rbp - 57 + rdx) = *(int8_t *)((r8 & 0x1f) + _sixBitToCharLookup);
                            rdx = rdx - 0x1;
                            r8 = r8 >> 0x5;
                    } while (rdx != 0x0);
            }
    }

    rax = *(int8_t *)(rbp - 56 + index) & 0xff;
    
    return rax;
}
  1. bp其实就是栈指针，这里使用bp说明是通过bp来操控栈空间的，然后每次循环dx都减1，然后r8左移6位或者5位，这个一般都是数组操作了，如果是5位的话最多存11个字节，所以这里使用一个长度11的数组buffer[11]，dx其实就会游离指针了我们用变量cursor表示

5.3.3 第三次简化

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
unsigned short -[NSTaggedPointerString characterAtIndex:](void * self, void * _cmd, unsigned long long arg2) {

    int8_t  buffer[11];
    r8 = self >> 0x8;
    
    if (length >= 0x8) {
            base = rbp - 57;
            cursor = length;
            if (length < 0xa) {
                    do {
                            buffer[base + cursor ] = *(int8_t *)((r8 & 0x3f) + _sixBitToCharLookup)
                            cursor = cursor - 0x1;
                            r8 = r8 >> 0x6;
                    } while (rdx != 0x0);
            }
            else {
                    do {
                            buffer[base + cursor ] = *(int8_t *)((r8 & 0x1f) + _sixBitToCharLookup);
                            cursor = cursor - 0x1;
                            r8 = r8 >> 0x5;
                    } while (rdx != 0x0);
            }
    }

    rax = *(int8_t *)(rbp - 56 + index) & 0xff;
    
    return rax;
}

_sixBitToCharLookup到底是什么呢，其实就是字符串

15471761831012.jpg

也就是eilotrm.apdnsIc ufkMShjTRxgC4013bDNvwyUL2O856P-B79AFKEWV_zGJ/HYX

其实程序还少了一段代码，hopper翻译伪代码的时候漏掉了

1
2
3
4
5
0000000000060d87         cmp        rbx, 0x8
0000000000060d8b         jb         loc_60dd1 // 当bs < 0x8时
...
loc_60dd1:
0000000000060dd1         mov        qword [rbp+var_38], r8

var_38就是-56

15471166175011.jpg

其实就是将r8的值放到[bp-56]的内存处，由于是小端存储，其实就是讲self>> 8的内容存放到对应的内存地址，类似于下面的代码，但是是占8个字节的

1
*(uint64_t *)buffer = self >> 8;

5.3.4 第四次简化

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
unsigned short -[NSTaggedPointerString characterAtIndex:](void * self, void * _cmd, unsigned long long arg2) {

    int8_t  buffer[11];
    r8 = self >> 0x8;
    
    if (length >= 0x8) {
       base = rbp - 57;
       cursor = length;
       _sixBitToCharLookup = 'eilotrm.apdnsIc ufkMShjTRxgC4013bDNvwyUL2O856P-B79AFKEWV_zGJ/HYX';
       if (length < 0xa) {
               do {
                   buffer[base + cursor ] = _sixBitToCharLookup[r8 & 0x3f]
                   cursor = cursor - 0x1;
                   r8 = r8 >> 0x6;
               } while (rdx != 0x0);
       } else {
               do {
                   buffer[base + cursor ] = _sixBitToCharLookup[r8 & 0x1f];
                   cursor = cursor - 0x1;
                   r8 = r8 >> 0x5;
               } while (rdx != 0x0);
       }
    } else {
        *(uint64_t *)buffer = self >> 8;
    }

    rax = *(int8_t *)(rbp - 56 + index) & 0xff;
    
    return rax;
}

这就显而易见了，对于字符串苹果的处理如下：

  1. 对于小于8个字符的，使用的是8位存储；
  2. [8,10)的是通过6位存储的；
  3. [10,11]的是通过5位存储的。

根据这个结论我们再来看下5.1的现象，对于上面的判断条件分别选一个代表

5.3.4.1 小于8位代表0x66656463626165 -> abcdef

可以看出是直接存储的；

5.3.4.2 [8,10)代表：0x22038a01169585 -> abcdefgh

去掉后面的95剩下0x22038a011695，6位排列如下

001000 100000 001110 001010 000000 010001 011010 010101，每一个就对应这个字符串eilotrm.apdnsIc ufkMShjTRxgC4013bDNvwyUL2O856P-B79AFKEWV_zGJ/HYX的索引值，为了方便查找做了一个对照表

15469350941106.jpg

所以

001000 100000 001110 001010 000000 010001 011010 010101

分别对应

a b c d e f g h

5.3.4.3 [10,11]位代表abcdefghij

但是这个类是__NSCFString并不是我们的NSTaggedPointerString，按道理说5位的话是可以存放10个字节的啊，这是什么原因呢？

原来：不管是5位还是6位都是查询的同一个字符串eilotrm.apdnsIc ufkMShjTRxgC4013bDNvwyUL2O856P-B79AFKEWV_zGJ/HYX，也就是上图索引表的颜色区分，5位里面没有包含b字符，但是我们的abcdefghij有b字符，所以不行，修改demo如下看看

1
2
3
4
5
6
7
8

NSString *str = [NSString stringWithFormat:@"acdefghijk"];
NSString *str2 = [NSString stringWithFormat:@"acdefghijkm"];
NSString *str3 = [NSString stringWithFormat:@"acdefghijkmn"];
    
NSLog(@"真实地址：0x%lx %@ %@", str,_objc_decodeTaggedPointer_(str), str3, object_getClass(str));
NSLog(@"真实地址：0x%lx %@ %@", str2,_objc_decodeTaggedPointer_(str2), str3, object_getClass(str2));
NSLog(@"真实地址：0x%lx %@ %@", str3,_objc_decodeTaggedPointer_(str3), str3, object_getClass(str3));

输出

1
2
3
真实地址：0x10e5023aa86d2a5 acdefghijk NSTaggedPointerString
真实地址：0x21ca047550da46b5 acdefghijkm NSTaggedPointerString
真实地址：0xc64838cff22b0b46 acdefghijkmn __NSCFString

可以看到能够支持11个字节了，0x10e5023aa86d2a5去掉0x10e5023aa86d2，按5位排列下看看

01000 01110 01010 00000 10001 11010 10101 00001 10110 10010

也就是 a c d e f g h i j k

所以我们可以得出能够存[10,11]位字符是以所存字符在eilotrm.apdnsIc ufkMShjTRxgC4013内为前提的。

最后再来看下苹果对于非ASCII是怎么处理的，以汉字方（Unicode）编码为\u65b9,占3个字节，按道理也是可以放进指针里面的，我们看看苹果有没有这样做

1
2
3
NSString *notAscii_1 = [NSString stringWithFormat:@"方"];

NSLog(@"源地址：%p  %@ %@", notAscii_1,notAscii_1, object_getClass(notAscii_1));

输出

1
源地址：0x101907df0  方 __NSCFString

发现苹果并没有放进指针内，而是真实的oc对象。

至此，我们之前的猜测一一验证了。

下面总结一下TaggedPointer的特点

六、什么样的字符会放进TaggedPointer？

总结了以下表格，注意这个只适用ASCII的情况，对于非ASCII都是使用的oc对象。

15471895085356.jpg

传入的字符任意一个不在所在行的范围，存的地方就会发生变化。

七、一个和TaggedPointer相关的面试题

下面代码会发生什么问题？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

@property (nonatomic, copy) NSString *target;
//.... dispatch_queue_t queue = dispatch_queue_create("parallel", DISPATCH_QUEUE_CONCURRENT);

// 方式一
for (int i = 0; i < 1000000 ; i++) {
    dispatch_async(queue, ^{
        self.target = [NSString stringWithFormat:@"ksddkjalkjd%d",I];
    });
}



//.... dispatch_queue_t queue = dispatch_queue_create("parallel", DISPATCH_QUEUE_CONCURRENT);
// 方式二
for (int i = 0; i < 1000000 ; i++) {
    dispatch_async(queue, ^{
        self.target = [NSString stringWithFormat:@"ksddkjalkj"];
    });
}

先说下结果吧 ，方式一会闪退，方式二正常运行。

分析这个道题，target的set方法实现

1
2
3
4
5
6
- (void)setTarget:(NSString *)target {
    if(_target != target) {
        [_target release];
        target = [target retain];
    }
}

方式一是真正的oc对象，由于是多线程会出现[_target release];被调用多次，从而闪退；
方式二不是oc对象，而是TaggedPointer,在release和retain的时候都会判断是不是TaggedPointer

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

objc_object::rootRelease(bool performDealloc, bool handleUnderflow)
{
    if (isTaggedPointer()) return false;

    bool sideTableLocked = false;
    ...
}


ALWAYS_INLINE id 
objc_object::rootRetain(bool tryRetain, bool handleOverflow)
{
    if (isTaggedPointer()) return (id)this;

}

其他的方式可以加锁解决，就不说了。

感谢

  1. http://www.ruanyifeng.com/blog/2007/10/ascii_unicode_and_utf-8.html
  2. https://mikeash.com/pyblog/friday-qa-2015-07-31-tagged-pointer-strings.html
赏

谢谢你请我吃糖果

微信
访问量次

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

FangLaoDa ，<br>Coder</br> <br> 目前就职于点融网 </br>