iOS 性能优化（内存布局&内存管理策略）
内存布局
内存布局中有七个区，分别是
内核区、堆区、栈区、未初始化数据（静态区）、已初始化数据（常量区）、代码段、保留区。 c++
- 栈区：建立临时变量时由编译器自动分配，在不须要的时候自动清除的变量的存储区。里面的变量一般是局部变量、函数参数等。在一个进程中，位于用户虚拟地址空间顶部的是用户栈，编译器用它来实现函数的调用。和堆同样，用户栈在程序执行期间能够动态地扩展和收缩。
- 堆区：那些由 new alloc 建立的对象所分配的内存块，它们的释放系统不会主动去管，由咱们的开发者去告诉系统何时释放这块内存(一个对象引用计数为0是系统就会回销毁该内存区域对象)。通常一个 new 就要对应一个release。在ARC下编译器会自动在合适位置为OC对象添加release操做。会在当前线程Runloop退出或休眠时销毁这些对象，MRC则需程序员手动释放。堆能够动态地扩展和收缩。
- 未初始化数据（静态区）：程序运行过程内存的数据一直存在，程序结束后由系统释放
- 已初始化数据（常量区）：专门用于存放常量，程序结束后由系统释放
- 代码段：用于存放程序运行时的代码，代码会被编译成二进制存进内存的程序代码区
- 内核区：用于加载内核代码，预留1GB
- 保留区：内存有4MB保留，地址从低到高递增
下面用代码来探索一下平常使用的数据存放在哪一个区程序员
- 栈区：
指针，以及一些简单的基本数据类型存储在栈区。通常来讲，地址为0x7开头的通常都是在栈区
#import "ViewController.h"
@interface ViewController ()
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
NSLog(@"************栈区************");
// 栈区
int a = 10;
int b = 20;
NSObject *object = [NSObject new];
NSLog(@"a == \t%p",&a);
NSLog(@"b == \t%p",&b);
NSLog(@"object == \t%p",&object);
NSLog(@"%lu",sizeof(&object));
NSLog(@"%lu",sizeof(a));
}
@end
复制代码
打印：算法
2020-02-13 16:33:11.605082+0800 001---五大区Demo[1545:519291] ************栈区************
2020-02-13 16:33:11.605169+0800 001---五大区Demo[1545:519291] a == 0x7ffee0cd87fc
2020-02-13 16:33:11.605236+0800 001---五大区Demo[1545:519291] b == 0x7ffee0cd87f8
2020-02-13 16:33:11.605298+0800 001---五大区Demo[1545:519291] object == 0x7ffee0cd87f0
2020-02-13 16:33:11.605357+0800 001---五大区Demo[1545:519291] 8
2020-02-13 16:33:11.605411+0800 001---五大区Demo[1545:519291] 4
复制代码
- 堆区：
堆区通常用来储存new出来的对象，通常来讲，堆区的地址通常为0x6开头
#import "ViewController.h"
@interface ViewController ()
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
NSLog(@"************堆区************");
// 堆区
NSObject *object1 = [NSObject new];
NSObject *object2 = [NSObject new];
NSObject *object3 = [NSObject new];
NSObject *object4 = [NSObject new];
NSObject *object5 = [NSObject new];
NSObject *object6 = [NSObject new];
NSObject *object7 = [NSObject new];
NSObject *object8 = [NSObject new];
NSObject *object9 = [NSObject new];
NSLog(@"object1 = %@",object1);
NSLog(@"object2 = %@",object2);
NSLog(@"object3 = %@",object3);
NSLog(@"object4 = %@",object4);
NSLog(@"object5 = %@",object5);
NSLog(@"object6 = %@",object6);
NSLog(@"object7 = %@",object7);
NSLog(@"object8 = %@",object8);
NSLog(@"object9 = %@",object9);
}
@end
复制代码
打印：数组
2020-02-13 16:33:11.605468+0800 001---五大区Demo[1545:519291] ************堆区************
2020-02-13 16:33:11.605531+0800 001---五大区Demo[1545:519291] object1 = <NSObject: 0x600003854440>
2020-02-13 16:33:11.605601+0800 001---五大区Demo[1545:519291] object2 = <NSObject: 0x600003854460>
2020-02-13 16:33:11.605655+0800 001---五大区Demo[1545:519291] object3 = <NSObject: 0x600003854450>
2020-02-13 16:33:11.605720+0800 001---五大区Demo[1545:519291] object4 = <NSObject: 0x600003854470>
2020-02-13 16:33:11.605776+0800 001---五大区Demo[1545:519291] object5 = <NSObject: 0x600003854480>
2020-02-13 16:33:11.605840+0800 001---五大区Demo[1545:519291] object6 = <NSObject: 0x600003854490>
2020-02-13 16:33:11.605902+0800 001---五大区Demo[1545:519291] object7 = <NSObject: 0x6000038544a0>
2020-02-13 16:33:11.605965+0800 001---五大区Demo[1545:519291] object8 = <NSObject: 0x6000038544b0>
2020-02-13 16:33:11.606028+0800 001---五大区Demo[1545:519291] object9 = <NSObject: 0x6000038544c0>
复制代码
- 静态区：这里会存储一些定义出来可是未初始化的对象，通常来讲，
0x1开头的数据通常为常量区和静态区
#import "ViewController.h"
@interface ViewController ()
@end
@implementation ViewController
int clA;
static int bssA;
static NSString *bssStr1;
- (void)viewDidLoad {
[super viewDidLoad];
NSLog(@"************静态区************");
NSLog(@"clA == \t%p",&clA);
NSLog(@"bssA == \t%p",&bssA);
NSLog(@"bssStr1 == \t%p",&bssStr1);
}
@end
复制代码
打印：安全
2020-02-13 16:33:11.623869+0800 001---五大区Demo[1545:519291] ************静态区************
2020-02-13 16:33:11.623950+0800 001---五大区Demo[1545:519291] clA == 0x10ef2729c
2020-02-13 16:33:11.624016+0800 001---五大区Demo[1545:519291] bssA == 0x10ef272a0
2020-02-13 16:33:11.624067+0800 001---五大区Demo[1545:519291] bssStr1 == 0x10ef272a8
复制代码
- 常量区：会存储一些定义出来且已经初始化的数据，通常来讲，
0x1开头的数据通常为常量区和静态区
#import "ViewController.h"
@interface ViewController ()
@end
@implementation ViewController
int clB = 10;
static int bssB = 10;
static NSString *bssStr2 = @"noah";
- (void)viewDidLoad {
[super viewDidLoad];
NSLog(@"************常量区************");
NSLog(@"clB == \t%p",&clB);
NSLog(@"bssB == \t%p",&bssB);
NSLog(@"bssStr2 == \t%p",&bssStr2);
}
@end
复制代码
打印：bash
2020-02-13 16:33:11.624130+0800 001---五大区Demo[1545:519291] ************常量区************
2020-02-13 16:33:11.624192+0800 001---五大区Demo[1545:519291] clB == 0x10ef271c0
2020-02-13 16:33:11.624244+0800 001---五大区Demo[1545:519291] bssB == 0x10ef271d0
2020-02-13 16:33:11.624300+0800 001---五大区Demo[1545:519291] bssStr2 == 0x10ef271c8
复制代码
内存管理策略
TaggedPointer
为何要使用taggedPointer?
假设要存储一个NSNumber对象，其值是一个整数。正常状况下，若是这个整数只是一个NSInteger的普通变量，在64位CPU下是占8个字节的。1个字节有8位，若是咱们存储一个很小的值，会出现不少位都是0的状况，这样就形成了内存浪费，苹果为了解决这个问题，引入了taggedPointer的概念。数据结构
- Tagged Pointer是苹果为了解决32位CPU到64位CPU的转变带来的内存占用和效率问题，针对NSNumber、NSDate以及部分NSString的内存优化方案。
- Tagged Pointer指针的值再也不是地址了，而是真正的值。因此，实际上它再也不是一个对象了，它只是一个披着对象皮的普通变量而已。因此，它的内存并不存储在堆中，也不须要malloc和free。
- Tagged Pointer指针中包含了当前对象的地址、类型、具体数值。所以Tagged Pointer指针在内存读取上有着3倍的效率，建立时比普通须要malloc跟free的类型快106倍。
- 若是想深刻了解TaggedPointer请点击这里
TaggedPointer源码多线程
// 建立
static inline void * _Nonnull
_objc_makeTaggedPointer(objc_tag_index_t tag, uintptr_t value)
{
if (tag <= OBJC_TAG_Last60BitPayload) {
uintptr_t result =
(_OBJC_TAG_MASK |
((uintptr_t)tag << _OBJC_TAG_INDEX_SHIFT) |
((value << _OBJC_TAG_PAYLOAD_RSHIFT) >> _OBJC_TAG_PAYLOAD_LSHIFT));
return _objc_encodeTaggedPointer(result);
} else {
uintptr_t result =
(_OBJC_TAG_EXT_MASK |
((uintptr_t)(tag - OBJC_TAG_First52BitPayload) << _OBJC_TAG_EXT_INDEX_SHIFT) |
((value << _OBJC_TAG_EXT_PAYLOAD_RSHIFT) >> _OBJC_TAG_EXT_PAYLOAD_LSHIFT));
return _objc_encodeTaggedPointer(result);
}
}
// 编码
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;
}
复制代码
系统对
taggedPointer进行了_objc_encodeTaggedPointer编码，该编码的实现就是对value进行了objc_debug_taggedpointer_obfuscator的异或操做，而在读取taggedPointer的时候，经过_objc_decodeTaggedPointer进行解码，仍是进行了objc_debug_taggedpointer_obfuscator的异或操做，这样进行了两次异或操做就还原了初始值。架构
使用代码来验证taggedpointer类型并发
#import "ViewController.h"
@interface ViewController ()
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
// Do any additional setup after loading the view, typically from a nib.
int num1 = 10;
float num2 = 12;
double num3 = 14;
long num4 = 5;
NSNumber * number1 = @(num1);
NSNumber * number2 = @(num2);
NSNumber * number3 = @(num3);
NSNumber * number4 = @(num4);
NSLog(@"number1 = %@ - %p - 0x%lx",number1,&number1,_objc_decodeTaggedPointer((__bridge const void * _Nullable)(number1)));
NSLog(@"number2 = %@ - %p - 0x%lx",number2,&number2,_objc_decodeTaggedPointer((__bridge const void * _Nullable)(number2)));
NSLog(@"number3 = %@ - %p - 0x%lx",number3,&number3,_objc_decodeTaggedPointer((__bridge const void * _Nullable)(number3)));
NSLog(@"number4 = %@ - %p - 0x%lx",number4,&number4,_objc_decodeTaggedPointer((__bridge const void * _Nullable)(number4)));
}
extern uintptr_t objc_debug_taggedpointer_obfuscator;
static inline uintptr_t
_objc_decodeTaggedPointer(const void * _Nullable ptr)
{
return (uintptr_t)ptr ^ objc_debug_taggedpointer_obfuscator;
}
@end
复制代码
打印
2020-02-13 19:35:33.310386+0800 004-taggedPointer[3472:589831] number1 = 10 - 0x7ffee4bcc7e0 - 0xb0000000000000a2
2020-02-13 19:35:33.310471+0800 004-taggedPointer[3472:589831] number2 = 12 - 0x7ffee4bcc7d8 - 0xb0000000000000c4
2020-02-13 19:35:33.310529+0800 004-taggedPointer[3472:589831] number3 = 14 - 0x7ffee4bcc7d0 - 0xb0000000000000e5
2020-02-13 19:35:33.310578+0800 004-taggedPointer[3472:589831] number4 = 5 - 0x7ffee4bcc7c8 - 0xb000000000000053
复制代码
以number1为例，通过
_objc_decodeTaggedPointer解码出来的值是0xb0000000000000a2，能够看到倒数第二位是值，倒数第一位是类型，能够得出最后一位二、四、五、3分别表明int long float double类型
再来看看字符串类型
//
// ViewController.m
// 004-taggedPointer
//
// Created by cooci on 2019/4/8.
// Copyright © 2019 cooci. All rights reserved.
//
#import "ViewController.h"
@interface ViewController ()
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
// Do any additional setup after loading the view, typically from a nib.
NSString * str1 = [NSString stringWithFormat:@"a"];
NSString * str2 = [NSString stringWithFormat:@"ab"];
NSString * str3 = [NSString stringWithFormat:@"abc"];
NSString * str4 = [NSString stringWithFormat:@"abcd"];
NSLog(@"str1 = %@ - %p - 0x%lx",str1,&str1,_objc_decodeTaggedPointer((__bridge const void * _Nullable)(str1)));
NSLog(@"str1 = %@ - %p - 0x%lx",str2,&str2,_objc_decodeTaggedPointer((__bridge const void * _Nullable)(str2)));
NSLog(@"str1 = %@ - %p - 0x%lx",str3,&str3,_objc_decodeTaggedPointer((__bridge const void * _Nullable)(str3)));
NSLog(@"str1 = %@ - %p - 0x%lx",str4,&str4,_objc_decodeTaggedPointer((__bridge const void * _Nullable)(str4)));
}
extern uintptr_t objc_debug_taggedpointer_obfuscator;
static inline uintptr_t
_objc_decodeTaggedPointer(const void * _Nullable ptr)
{
return (uintptr_t)ptr ^ objc_debug_taggedpointer_obfuscator;
}
@end
复制代码
打印：
2020-02-13 19:42:22.152170+0800 004-taggedPointer[3539:593334] str1 = a - 0x7ffee3bf27c0 - 0xa000000000000611
2020-02-13 19:42:22.152257+0800 004-taggedPointer[3539:593334] str1 = ab - 0x7ffee3bf27b8 - 0xa000000000062612
2020-02-13 19:42:22.152322+0800 004-taggedPointer[3539:593334] str1 = abc - 0x7ffee3bf27b0 - 0xa000000006362613
2020-02-13 19:42:22.152386+0800 004-taggedPointer[3539:593334] str1 = abcd - 0x7ffee3bf27a8 - 0xa000000646362614
复制代码
字符串类型解压出来的值，最后一位表明的是字符串长度，而
6一、6二、6三、64对应的是ASCII的a、b、c、d
NONPOINTER_ISA
苹果将 isa 设计成了联合体，在 isa 中存储了与该对象相关的一些内存的信息，缘由也如上面所说，并不须要 64 个二进制位所有都用来存储指针。来看一下 isa 的结构：
// x86_64 架构
struct {
uintptr_t nonpointer : 1; // 0:普通指针，1:优化过，使用位域存储更多信息
uintptr_t has_assoc : 1; // 对象是否含有或曾经含有关联引用
uintptr_t has_cxx_dtor : 1; // 表示是否有C++析构函数或OC的dealloc
uintptr_t shiftcls : 44; // 存放着 Class、Meta-Class 对象的内存地址信息
uintptr_t magic : 6; // 用于在调试时分辨对象是否未完成初始化
uintptr_t weakly_referenced : 1; // 是否被弱引用指向
uintptr_t deallocating : 1; // 对象是否正在释放
uintptr_t has_sidetable_rc : 1; // 是否须要使用 sidetable 来存储引用计数
uintptr_t extra_rc : 8; // 引用计数可以用 8 个二进制位存储时，直接存储在这里
};
// arm64 架构
struct {
uintptr_t nonpointer : 1; // 0:普通指针，1:优化过，使用位域存储更多信息
uintptr_t has_assoc : 1; // 对象是否含有或曾经含有关联引用
uintptr_t has_cxx_dtor : 1; // 表示是否有C++析构函数或OC的dealloc
uintptr_t shiftcls : 33; // 存放着 Class、Meta-Class 对象的内存地址信息
uintptr_t magic : 6; // 用于在调试时分辨对象是否未完成初始化
uintptr_t weakly_referenced : 1; // 是否被弱引用指向
uintptr_t deallocating : 1; // 对象是否正在释放
uintptr_t has_sidetable_rc : 1; // 是否须要使用 sidetable 来存储引用计数
uintptr_t extra_rc : 19; // 引用计数可以用 19 个二进制位存储时，直接存储在这里
};
复制代码
注意这里的
has_sidetable_rc和extra_rc，has_sidetable_rc代表该指针是否引用了 sidetable 散列表，之因此有这个选项，是由于少许的引用计数是不会直接存放在 SideTables 表中的，对象的引用计数会先存放在extra_rc中，当其被存满时，才会存入相应的 SideTables 散列表中，SideTables 中有不少张 SideTable，每一个 SideTable 也都是一个散列表，而引用计数表就包含在 SideTable 之中。
SideTables 散列表
散列表（Hash table，也叫哈希表），是根据建（Key）而直接访问在内存存储位置的数据结构。也就是说，它经过一个关于键值得函数，将所需查询的数据映射到表中一个位置来访问记录，这加快了查找速度。这个映射函数称做散列函数，存放记录的数组称做散列表。
来看一下 NSObject.mm 中它们对应的源码：
// SideTables
static StripedMap<SideTable>& SideTables() {
return *reinterpret_cast<StripedMap<SideTable>*>(SideTableBuf);
}
// SideTable
struct SideTable {
spinlock_t slock; // 自旋锁
RefcountMap refcnts; // 引用计数表
weak_table_t weak_table; // 弱引用表
// other code ...
};
复制代码
它们的关系以下：
// 获取一个sidetable
table = &SideTables()[obj];
// SideTables
static StripedMap<SideTable>& SideTables() {
return *reinterpret_cast<StripedMap<SideTable>*>(SideTableBuf);
}
复制代码
// StripedMap
template<typename T>
// 这里的模板规范了一个sidetable的样式
class StripedMap {
#if TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR
//若是是真机，StripeCount=8
enum { StripeCount = 8 };
#else
//模拟器就是StripeCount=64
enum { StripeCount = 64 };
#endif
struct PaddedT {
T value alignas(CacheLineSize);
};
PaddedT array[StripeCount];
// 散列算法
static unsigned int indexForPointer(const void *p) {
uintptr_t addr = reinterpret_cast<uintptr_t>(p);
// 这个算法保证算出来的值是小于StripeCount的，这样就不会出现数据越界的状况
return ((addr >> 4) ^ (addr >> 9)) % StripeCount;
}
public:
// 重写操做符
T& operator[] (const void *p) {
// 这里返回一个sidetable
return array[indexForPointer(p)].value;
}
const T& operator[] (const void *p) const {
return const_cast<StripedMap<T>>(this)[p];
}
...
};
复制代码
分离锁
分离锁并非一种锁，而是一种对锁的用法。各个元素分别加一把锁就是咱们说的分离锁。
问：为何不用SideTables 直接包含自旋锁，引用计数表和弱引用表呢？
答：
这是由于在众多线程同时访问这个 SideTable 表的时候，为了保证数据安全，须要给其加上自旋锁，若是只有一张 SideTable 的表，那么全部数据访问都会出一个进一个，单线程进行，很是影响效率，虽然自旋锁已是效率很是高的锁，这会带来很是很差的用户体验。针对这种状况，将一张 SideTable 分为多张表的 SideTables，再各自加锁保证数据的安全，这样就增长了并发量，提升了数据访问的效率，这就是为何一个 SideTables 下涵盖众多 SideTable 表的缘由。
自旋锁：计算机科学用于多线程同步的一种锁，线程会反复检查锁变量是否可用。因为线程在这一过程当中保持执行（没有进入休眠），所以是一种忙等。一旦获取了自旋锁，线程会一直保持该锁，直至显式释放自旋锁。
自旋锁适用于小型数据、耗时不多的操做，速度很快。
引用计数表（RefcountMap refcnts
SideTable中包含一个
c++Map RefcountMap refcnts用来对象存储额外的引用计数，一个结构体weak_table_t weak_table用来存储对象的弱引用数据RefcountMap refcnts 中经过一个size_t（64位系统中占用64位）来保存引用计数，其中1位用来存储固定标志位，在溢出的时候使用，一位表示正在释放中，一位表示是否有弱引用，其他位表示实际的引用计数
- RefcountMap refcnts 是一个C++的对象，内部包含了一个迭代器
- 其中以DisguisedPtr<objc_object> 对象指针为key，size_t 为value保存对象引用计数
- 将key、value经过std::pair打包之后，放入迭代器中，因此取出值以后，.first表明key，.second表明value
弱引用表
全局弱引用表 weak_table_t
struct weak_table_t {
weak_entry_t *weak_entries;
size_t num_entries;
uintptr_t mask;
uintptr_t max_hash_displacement;
};
复制代码
弱引用表的内部结构
struct weak_entry_t {
DisguisedPtr<objc_object> referent;
union {
struct {
weak_referrer_t *referrers;
uintptr_t out_of_line_ness : 2;
uintptr_t num_refs : PTR_MINUS_2;
uintptr_t mask;
uintptr_t max_hash_displacement;
};
struct {
// out_of_line_ness field is low bits of inline_referrers[1]
weak_referrer_t inline_referrers[WEAK_INLINE_COUNT];
};
};
};
复制代码
- 其中主要包含了两个属性
DisguisedPtr<objc_object> referent对象指针，还有一个容器类保存因此只需这个对象的弱引用 - 共用体中包含两种结构体，当弱引用数量少于
4的时候，使用数据结构来存储，当超过4个的时候使用hash表进行存储，out_of_line_ness默认为ob00，当弱引用数量大于4的时候，设置为REFERRERS_OUT_OF_LINEob10，经过判断out_of_line_ness来决定用什么方式存储 weak_referrer_t *referrers是一个二级指针实现的hash表
参考文章
相关文章
- 1. Android 内存优化策略
- 2. iOS性能优化-内存优化(1)
- 3. Redis 内存管理策略
- 4. Rs2008内存管理策略
- 5. Android 性能优化—内存管理
- 6. 性能优化-Bitmap内存管理
- 7. Android 性能优化(内存优化和布局优化)
- 8. 内存管理+内存布局
- 9. APP性能-内存优化-内存管理认知
- 10. iOS-内存管理(一)-布局&方案
- 更多相关文章...
- • Redis内存回收策略 - Redis教程
- • 内存数据库是什么？ - NoSQL教程
- • 三篇文章了解 TiDB 技术内幕——说存储
- • JDK13 GA发布：5大特性解读
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
相关文章
- 1. Android 内存优化策略
- 2. iOS性能优化-内存优化(1)
- 3. Redis 内存管理策略
- 4. Rs2008内存管理策略
- 5. Android 性能优化—内存管理
- 6. 性能优化-Bitmap内存管理
- 7. Android 性能优化(内存优化和布局优化)
- 8. 内存管理+内存布局
- 9. APP性能-内存优化-内存管理认知
- 10. iOS-内存管理(一)-布局&方案