一. 内存区域
验证上图，代码如下：
#import <UIKit/UIKit.h>
#import "AppDelegate.h"
int a = 10;
int b;
int main(int argc, char * argv[]) {
@autoreleasepool {
static int c = 20;
static int d;
int e;
int f = 20;
NSString *str1 = @"123";
NSString *str2 = @"123";
NSObject *obj = [[NSObject alloc] init];
NSLog(@"\n&a=%p\n&b=%p\n&c=%p\n&d=%p\n&e=%p\n&f=%p\nstr1=%p\nstr2=%p\nobj=%p\n",
&a, &b, &c, &d, &e, &f, str1, str2, obj);
return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));
}
}
运行后，整理打印：
代码段：函数都存放在代码段，由于函数地址没法直接打印，只能进入汇编查看，这里就省略了。
数据段：字符串常量
str1=0x10dfa0068
str2=0x10dfa0068
数据段：已初始化的全局变量、静态变量
&a =0x10dfa0db8
&c =0x10dfa0dbc
数据段：未初始化的全局变量、静态变量
&d =0x10dfa0e80
&b =0x10dfa0e84
堆：alloc动态分配的空间
obj=0x608000012210
栈：函数调用开销，比如局部变量
&f =0x7ffee1c60fe0
&e =0x7ffee1c60fe4
可以发现：
- 上面的内存地址从小到大。
- 字符串常量一样的时候，指针指向的内存地址也一样，说明保存在内存中只有一份内存。
- 栈里面内存分配的确是从大到小的。先分配e，再分配f，所以e内存地址比f大。
- 堆和栈地址位数比较多，说明系统给堆、栈预留的空间比较大。
二. Tagged Pointer技术
1. 关于Tagged Pointer
- 从64bit开始，iOS引入了Tagged Pointer技术，用于优化NSNumber、NSDate、NSString等小对象的存储，Tagged Pointer技术是编译器帮我们做的。
- 在没有使用Tagged Pointer之前， NSNumber等对象需要动态分配内存、维护引用计数等，NSNumber指针存储的是堆中NSNumber对象的地址值。
- 使用Tagged Pointer之后，NSNumber指针里面存储的数据变成了：Tag + Data，也就是将数据直接存储在了指针中，其中Tag是标记是什么类型，比如NSNumber、NSDate、NSString等。
- 当指针不够存储数据时，才会使用动态分配内存的方式来存储数据。
- objc_msgSend能识别Tagged Pointer，比如NSNumber的intValue方法，优点就是直接从指针提取数据，节省了以前的调用开销，同时也会节省内存。
- 如何判断一个指针是否为Tagged Pointer？
iOS平台，转换成二进制，最高有效位是1（第64bit位）
Mac平台，转换成二进制，最低有效位是1（第0bit位）
2. 为什么使用Tagged Pointer？
使用Tagged Pointer，就是直接从指针提取数据，节省了以前的调用开销，同时也会节省内存。
可以发现，使用Tagged Pointer之前，如果想要保存10，需要包装成NSNumber对象(16字节)，NSNumber对象里面放着10，然后用number指针(8字节)指向NSNumber对象，至少需要24字节。
使用Tagged Pointer之后，number指针(8字节)里面保存的就是16进制的10：0xb000a1。其中0x代表16进制，b就是标记NSNumber类型，a是16进制的10，1代表使用了Tagged Pointer技术，这样，8字节就能存放NSNumber类型的10了。
3. 举例证明
创建命令行项目(Mac平台的)，举例证明：
#import <Foundation/Foundation.h>
//是否使用了TaggedPointer技术
BOOL isTaggedPointer(id pointer)
{
return (long)(__bridge void *)pointer & 1;
}
int main(int argc, const char * argv[]) {
@autoreleasepool {
// //完整写法
// NSNumber *number = [NSNumber numberWithInt:10];
// //简写
// NSNumber *number = @10;
//再简写
NSNumber *number1 = @4;
NSNumber *number2 = @5;
NSNumber *number3 = @(0xFFFFFFFFFFFFFFF);//数字很大，存储的是对象
NSLog(@"%p %p %p", number1, number2, number3);
NSLog(@"%d %d %d", isTaggedPointer(number1), isTaggedPointer(number2), isTaggedPointer(number3));
}
return 0;
}
打印结果为：
0x77f92be9bdbfa067 0x77f92be9bdbfa167 0x100575490
1 1 0
前两个数字比较小，使用了Tagged Pointer技术，第3个数字比较大，被包装成NSNumber对象，放在了堆空间。
前两个地址，末尾都是7，转成二进制就是0b0111，最后末尾是1，说明使用了Tagged Pointer技术，可以使用&1获取最后一位，根据最后一位是否为1，判断是否使用了Tagged Pointer技术(如上打印)。
第三个地址，末尾是0，转成二进制就是0b0000，被包装成了NSNumber对象。因为OC对象有内存对齐的概念，OC对象的内存大小必须是16的倍数，所以只要是OC对象，内存地址最后一位一定是0。
如果将number1转成int：
[number1 intValue]
其实就是objc_msgSend(number1, @selector(intValue))，objc_msgSend能识别Tagged Pointer，number1使用了Tagged Pointer，所以转成int的时候，是直接取出number1里面的值，节省了调用开销。可以发现，Tagged Pointer不仅仅是内存空间的优化，还是使用上的优化。
4. 补充：查看OC源码是如何判断是否使用了Tagged Pointer的？
在objc4里面搜索到如下源码：
#if TARGET_OS_OSX && __x86_64__
// 如果是Mac平台，设置为0
# define OBJC_MSB_TAGGED_POINTERS 0
#else
// 其他平台(iOS平台)，设置为1
# define OBJC_MSB_TAGGED_POINTERS 1
#endif
#if OBJC_MSB_TAGGED_POINTERS //如果是iOS平台
# define _OBJC_TAG_MASK (1UL<<63) //1左移63位
#else //如果是Mac平台
# define _OBJC_TAG_MASK 1UL //1
#endif
static inline bool
_objc_isTaggedPointer(const void * _Nullable ptr)
{
return ((uintptr_t)ptr & _OBJC_TAG_MASK) == _OBJC_TAG_MASK;
}
可以发现，和我们上面说的一样，如果是iOS平台，就看最高有效位是不是1，如果是Mac平台，就看最低有效位是不是1。
三. 面试题
思考以下两段代码能发生什么事？有什么区别？
@property (copy, nonatomic) NSString *name;
dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
for (int i = 0; i < 1000; i++) {
dispatch_async(queue, ^{
self.name = [NSString stringWithFormat:@"abcdefghijk"];
});
}
for (int i = 0; i < 1000; i++) {
dispatch_async(queue, ^{
self.name = [NSString stringWithFormat:@"abc"];
});
}
运行之后，第一段代码报错坏内存访问，并且崩在objc_release这个函数。第二段代码没问题。
1. 为什么报坏内存访问错误？
我们知道，上面的setter方法，ARC内部实现是：
- (void)setName:(NSString *)name
{
_name = name;
}
ARC最终都要转成MRC，MRC内部实现是：
- (void)setName:(NSString *)name
{
if (_name != name) {
[_name release]; //先释放旧的
_name = [name copy]; //再赋值新的
}
}
问题就出在 [_name release]，当多条线程同时调用setter方法的时候，就有可能多个线程同时访问[_name release]，刚开始引用计数器为1，当第二次release的时候，_name已经释放了，这时候再访问_name就会报错：坏内存访问。
2. 如何解决呢？
改用atomic修饰，不推荐，具体可参考：加锁方案2
调用setter方法之前加锁，如下：
// 在这里加锁
self.name = [NSString stringWithFormat:@"abcdefghijk"];
// 在这里解锁
具体怎么加锁可参考：加锁方案1
3. 为什么第二段代码不会崩溃？
首先，运行以下代码：
NSString *str1 = [NSString stringWithFormat:@"abcdefghijk"];
NSString *str2 = [NSString stringWithFormat:@"abc"];
NSLog(@"%@ %@", [str1 class], [str2 class]);
NSLog(@"%p %p",str1, str2);
打印：
__NSCFString NSTaggedPointerString
0x6000037fa1a0 0xec1baa29b42aee38
根据上面我们学的Tagged Pointer技术，结合打印的类型信息，很容易知道，str1是OC对象，str2使用了Tagged Pointer技术，abc的值直接存储到str2指针里面了。所以，对于str2，不是OC对象，不会调用setter方法，而是直接从指针里面获取值，所以不会出现上面的崩溃。
4. 补充：验证str2使用了Tagged Pointer技术
由于上面代码是iOS项目，如果将0xec1baa29b42aee38转成二进制，最高位是1，说明使用了Tagged Pointer技术。
将0xec1baa29b42aee38转成二进制，如下：
可以发现，最高位第64位 (0 - 63)，的确是1，说明真的使用了Tagged Pointer技术。
Demo地址：内存区域、Tagged Pointer技术
