--- theme: v-green --- ![5e575953c6bbc1582782803291.jpg](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/44e541e681514f8a8fe02999dd30a66a~tplv-k3u1fbpfcp-jj-mark:0:0:0:0:q75.image#?w=4724&h=2362&s=6279233&e=jpg&b=6fbde4) # 背景 > 前面[swift类对象和示例对象探究](https://juejin.cn/post/7312727134297489442)文章，我们知道它们的底层逻辑以及内存布局，这篇文章我们再探究下swift的内存管理 # 值类型内存 ```js var var1 = StructMemoryTest() print("var1:") print(withUnsafePointer(to: &var1) {ptr in print(ptr)}) var var2 = var1 print("var2: ") print(withUnsafePointer(to: &var2) {ptr in print(ptr)}) var var3 = var2 print("var3:") print(withUnsafePointer(to: &var3) {ptr in print(ptr)}) ``` 运行： ![Xnip2023-12-18_15-33-02.jpg](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/4daa14361c5a4c4b97600ca1100c216b~tplv-k3u1fbpfcp-jj-mark:0:0:0:0:q75.image#?w=1550&h=262&s=31168&e=jpg&b=201f25) 可以看到对于结构体值类型的赋值是深拷贝 **再深入探究下底层逻辑** ```js import Foundation struct Student { var name:String var age:Int } var stu = Student(name: "小李", age: 28) ``` 我们发现可以直接调用Student的初始化方法，但是我们并没有写Student的初始化方法编译为sil，发现实际底层给添加了初始化方法 ![Xnip2023-12-18_15-46-30.jpg](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/c29438a0467149bb81d5e44661794ecb~tplv-k3u1fbpfcp-jj-mark:0:0:0:0:q75.image#?w=1622&h=320&s=67248&e=jpg&b=4c4c4c) 再通过一个例子我们修复test2的age,test1的age也不会受影响 ```js struct StructMemoryTest { var name:String? var age:Int? } var test1 = StructMemoryTest(name: "小李", age: 28) var test2 = test1 test2.age = 30 print("test1.age:\(test1.age) test2.age:\(test2.age)") ``` ![Xnip2023-12-18_16-10-15.jpg](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/3a340003e85445f1aa8890652d669514~tplv-k3u1fbpfcp-jj-mark:0:0:0:0:q75.image#?w=1882&h=554&s=142644&e=jpg&b=201f25) ## 总结值类型 - 值类型存储在栈空间 - 值类型的赋值都是值传递，深拷贝 # 引用类型内存引用类型分强弱引用，下面我们都分别看下实现原理 ## 强引用 ```js class ClassMemoryTest { var name:String? var age:Int? } var t = ClassMemoryTest() var t1 = t ``` 运行看t赋值给t1，它们的内存地址是不一样的 ![Xnip2023-12-18_16-44-24.jpg](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/56404d409c64452aadc5cdd2a5665f4e~tplv-k3u1fbpfcp-jj-mark:0:0:0:0:q75.image#?w=1534&h=218&s=53680&e=jpg&b=201f25) 再看下类的内存布局 ![Xnip2023-12-18_16-45-55.jpg](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/2fb9777b53094fbea7393f00e18953ea~tplv-k3u1fbpfcp-jj-mark:0:0:0:0:q75.image#?w=950&h=262&s=89996&e=jpg&b=212026) 前面章节我们知道swift类的前16位分别是元类和引用计数相关数据 **说明：** - 直接将对象赋值给一个变量，就是强引用 - 可以查看此时的refCounts的值 #### 1.refCounts的认识通过在底层源码中查找HeapObject来查看对象引用的计数。引用计数refCounts属性其本质是RefCountsInt类型，包含unit32_t Type和int32_t SignedType **👇1.1 HeapObject** ```js // HeapObject头文件中不被标准的Objective-C实例共享的成员 // The members of the HeapObject header that are not shared by a // standard Objective-C instance #define SWIFT_HEAPOBJECT_NON_OBJC_MEMBERS \ InlineRefCounts refCounts /// The Swift heap-object header. /// This must match RefCountedStructTy in IRGen. struct HeapObject { /// This is always a valid pointer to a metadata object. /// 总是一个指向元类的指针 HeapMetadata const *__ptrauth_objc_isa_pointer metadata; // 引用计数相关 SWIFT_HEAPOBJECT_NON_OBJC_MEMBERS; // 构造函数 // Initialize a HeapObject header as appropriate for a newly-allocated object. constexpr HeapObject(HeapMetadata const *newMetadata) : metadata(newMetadata) , refCounts(InlineRefCounts::Initialized) { } ... } ``` **说明：** - 对象在底层是HeapObject - 所以在源码中查看HeapObject，发现引用是SWIFT_HEAPOBJECT_NON_OBJC_MEMBERS - 通过SWIFT_HEAPOBJECT_NON_OBJC_MEMBERS的定义可以看到是refCounts的类型是**InlineRefCounts** - HeapObject的构造函数执行插传入引用计数位InlineRefCounts::Initialized **👇1.2 InlineRefCounts** ```js typedef RefCounts InlineRefCounts; ... template class RefCounts { std::atomic refCounts; ... } ``` - 查看InlineRefCounts，发现它是**RefCounts**的别名 - 而RefCounts的成员是refCounts，它是由**RefCountBits**决定的 - 因此是InlineRefCounts通过**InlineRefCountBits**来决定里面的值 **👇1.2.1 InlineRefCountBits** ```js typedef RefCountBitsT InlineRefCountBits; ``` - InlineRefCountBits是RefCountBitsT的别名，传入RefCountIsInline **👇1.2.2 RefCountBitsT** ```js // Basic encoding of refcount and flag data into the object's header. template class RefCountBitsT { friend class RefCountBitsT; friend class RefCountBitsT; static const RefCountInlinedness Inlinedness = refcountIsInline; typedef typename RefCountBitsInt::Type BitsType; ... } struct RefCountBitsInt { typedef uint64_t Type; typedef int64_t SignedType; }; ``` - 可以看到有一个bits属性，这个属性就是Bits - bits其实质是将RefCountBitsInt中的type属性取了一个别名 - 所以bits的真正类型是uint64_t即64位整型的数组，包含Type和SignedType两个成员 **总结：** > 到这里有个重要消息是refCounts中其实包含有Bits成员，而这个成员是64位整型的数组。 #### 2. refCounts的赋值探索前面文章提高对象创建过程，swift源码是从swift_allocObject开始的 ```js static HeapObject *_swift_allocObject_(HeapMetadata const *metadata, size_t requiredSize, size_t requiredAlignmentMask) { assert(isAlignmentMask(requiredAlignmentMask)); auto object = reinterpret_cast( swift_slowAlloc(requiredSize, requiredAlignmentMask)); // NOTE: this relies on the C++17 guaranteed semantics of no null-pointer // check on the placement new allocator which we have observed on Windows, // Linux, and macOS. ::new (object) HeapObject(metadata); ... return object; } // HeapObject构造函数 constexpr HeapObject(HeapMetadata const *newMetadata) : metadata(newMetadata) , refCounts(InlineRefCounts::Initialized) { } ``` - 通过swift_allocObject方法来构造对象，因此在这里会进行对象中引用属性的赋值 - 可以看到是通过refCounts来给引用计数赋值的,传入的参数是Initialized **👇2.1 Initialized** ```js enum Initialized_t { Initialized }; ``` ![Xnip2023-12-18_17-25-02.jpg](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/ccfd5ca2bb694a2a95c9518780bea90b~tplv-k3u1fbpfcp-jj-mark:0:0:0:0:q75.image#?w=2018&h=374&s=117667&e=jpg&b=242228) - 进入Initialized定义，是一个枚举 - 其对应的refCounts方法中，看出真正干事的是RefCountBits **👇 2.2 RefCountBits** ```js template class RefCounts { std::atomic refCounts; ... } ``` - 进入RefCountBits定义，也是一个模板定义 **👇 2.2 RefCountBitsT** ```js SWIFT_ALWAYS_INLINE constexpr RefCountBitsT(uint32_t strongExtraCount, uint32_t unownedCount) : bits((BitsType(strongExtraCount) << Offsets::StrongExtraRefCountShift) | (BitsType(1) << Offsets::PureSwiftDeallocShift) | (BitsType(unownedCount) << Offsets::UnownedRefCountShift)) { } ``` - 这里就是真正的初始化地方 - 实际上是做了一个位域操作 **👇2.3 RefCountsBit结构** 经过上文的查找，可以得到RefCountsBit结构 ![16620449989227.jpg](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/fa5fae1ef39746bc8ec6cff0819eda76~tplv-k3u1fbpfcp-jj-mark:0:0:0:0:q75.image#?w=655&h=310&s=12942&e=webp&b=f1f1f1) - isImmortal（0） - UnownedRefCount（1-31）：unowned的引用计数 - isDeinitingMask（32）：是否进行释放操作 - StrongExtraRefCount（33-62）：强引用计数 - UseSlowRC（63） **总结设置引用计数** > 设置引用计数实际是对底层的RefCountsBit数据结构进行位域操作 **👇2.4 创建对象查看引用计数** ```js class Teacher { func teach() { print("教语文课") } } var teacher = Teacher() var t1= teacher ``` 2.4.1 第一次创爱对象 ![Xnip2023-12-18_17-47-47.jpg](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/e28d81c19a4b436d825553fab956c1df~tplv-k3u1fbpfcp-jj-mark:0:0:0:0:q75.image#?w=1564&h=680&s=324498&e=jpg&b=212026) - 先创建一个全局的实例变量 - 之后创建对象 - 将对象赋值给全局变量 2.4.2 第二次创建对象 ![Xnip2023-12-18_17-48-35.jpg](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/5296c5b2f7fe4087a8a8133cf07c1026~tplv-k3u1fbpfcp-jj-mark:0:0:0:0:q75.image#?w=1510&h=746&s=311816&e=jpg&b=212026) - 创建t1 - 把t1赋值给%9 - 把teacher %3 赋值为 %10 - copy_addr 将 %10 赋值为 %9 - %new = load $*LGTeacher（拿到这个对象） - strong_retain %new（给这个对象引用计数加一） - store %new to %9（将这个对象赋给t1） copy_addr最主要的就是对这个对象做了一下strong_ratain。之后再进行赋值操作 SIL官方文档中关于`copy_addr`的解释如下 ![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/7b06e9c8c947460fb9accdc0408f2f8c~tplv-k3u1fbpfcp-jj-mark:0:0:0:0:q75.image#?w=1410&h=774&s=48022&e=webp&b=f6f8fa) 2.4.3 swift_retain的认识 > strong_retain对应的就是 swift_retain，其内部是一个宏定义，内部是_swift_retain_，其实现是对object的引用计数作+1操作。 ```js SWIFT_ALWAYS_INLINE static HeapObject *_swift_retain_(HeapObject *object) { SWIFT_RT_TRACK_INVOCATION(object, swift_retain); if (isValidPointerForNativeRetain(object)) object->refCounts.increment(1); return object; } ... // Increment the reference count. SWIFT_ALWAYS_INLINE void increment(uint32_t inc = 1) { auto oldbits = refCounts.load(SWIFT_MEMORY_ORDER_CONSUME); // 如果需要新增计数不等于1 并且旧的bits是永生的 ->不处理后续逻辑 // constant propagation will remove this in swift_retain, it should only // be present in swift_retain_n if (inc != 1 && oldbits.isImmortal(true)) { return; } //64位bits RefCountBits newbits; do { newbits = oldbits; bool fast = newbits.incrementStrongExtraRefCount(inc); if (SWIFT_UNLIKELY(!fast)) { if (oldbits.isImmortal(false)) return; return incrementSlow(oldbits, inc); } } while (!refCounts.compare_exchange_weak(oldbits, newbits, std::memory_order_relaxed)); } ``` - 通过refCounts.increment(1);进行引用计数+1 - 在increment方法中是通过incrementStrongExtraRefCount来实现计数的 2.4.5 incrementStrongExtraRefCount ```js // Returns true if the increment is a fast-path result. // Returns false if the increment should fall back to some slow path // (for example, because UseSlowRC is set or because the refcount overflowed). SWIFT_NODISCARD SWIFT_ALWAYS_INLINE bool incrementStrongExtraRefCount(uint32_t inc) { // 对inc做强制类型转换为 BitsType // 其中 BitsType(inc) << Offsets::StrongExtraRefCountShift 等价于 1<<33位，16进制为 0x200000000 //这里的 bits += 0x200000000，将对应的33-63转换为10进制，为 // This deliberately overflows into the UseSlowRC field. bits += BitsType(inc) << Offsets::StrongExtraRefCountShift; return (SignedBitsType(bits) >= 0); } ``` - 通过位域进行偏移 - 我们知道refCounts中的62-33位是strongCount，这里的位域目的就是将引用计数加在这里 - 每次的增加为1左移33位 - 也就是每次增加0x200000000 - 也就是BitsType(inc) << Offsets::StrongExtraRefCountShift **总结：** - swift中创建实例对象时默认为1 - 强引用计数存储在refCounts中的33-62位，因此每次引用计数+1，都要加上0x200000000 ## 弱引用 > 主要认识弱引用的使用、以及散列表的存储结构。散列表不仅存储了弱引用，还有强引用和无主引用，如果有弱引用，在refCounts中直接使用散列表的地址 **弱引用的使用** ```js class Student { var name:String = "" var age:Int = 0 } var stu = Student() weak var weakStu = stu ``` - 给变量t赋值给弱引用t1 - 弱引用声明的变量是一个可选值，因为在程序运行过程中是允许将当前变量设置为nil的 debug调试看下汇编代码 ![Xnip2023-12-18_19-23-16.jpg](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/e52c8318e3804a26b0d1dc79f77a0d0c~tplv-k3u1fbpfcp-jj-mark:0:0:0:0:q75.image#?w=2226&h=420&s=227478&e=jpg&b=201f25) - 前面我们知道当把对象赋值另外一个变量时，底层会执行swift_allocObject析建变量承接数据，这里当把对象赋值为一个weak修饰的变量时，底层走swift_weakInit **swift_weakInit** ```js WeakReference *swift::swift_weakInit(WeakReference *ref, HeapObject *value) { ref->nativeInit(value); return ref; } ``` 参数 | 参数 | 含义 | | --- | --- | | ref | 弱引用指针 | | value | 弱引用指针指向的宿主对象 | - 查看swift_weakInit，可以看到系统本身提供了一个WeakReference类，用来进行引用计数的创建 - 这个ref对象调用nativeInit，传入对象，就可以创建弱引用了 **若引用对象的nativeInit函数** ```js void nativeInit(HeapObject *object) { auto side = object ? object->refCounts.formWeakReference() : nullptr; nativeValue.store(WeakReferenceBits(side), std::memory_order_relaxed); } ``` - 调用宿主对象的refCounts的formWeakReference完成弱引用映射 **宿主对象的refCounts的formWeakReference** ```js // SideTableRefCountBits specialization intentionally does not exist. template <> HeapObjectSideTableEntry* RefCounts::formWeakReference() { auto side = allocateSideTable(true); if (side) return side->incrementWeak(); else return nullptr; } ``` - 创建散列表 - 通过incrementWeak()给散列表增加弱引用 **allocateSideTable创建散列表** ```js // 返回一个对象的side table散列表，如果有必要再创建 // Return an object's side table, allocating it if necessary. // 如果对象在执行析构函数返回一个null出去 // Returns null if the object is deiniting. // SideTableRefCountBits specialization intentionally does not exist. template <> HeapObjectSideTableEntry* RefCounts::allocateSideTable(bool failIfDeiniting) { //1、先拿到原本的引用计数 auto oldbits = refCounts.load(SWIFT_MEMORY_ORDER_CONSUME); //2. 预检查操作 //在创建新的side table之前判断旧的引用计数是否已经使用散列表side table 如果存在返回已经存在的side table // Preflight failures before allocating a new side table. if (oldbits.hasSideTable()) { // Already have a side table. Return it. return oldbits.getSideTable(); } // 如果宿主对象正在执行析构函数直接返回null else if (failIfDeiniting && oldbits.getIsDeiniting()) { // Already past the start of deinit. Do nothing. return nullptr; } // Preflight passed. Allocate a side table. //3. 创建sidetable // FIXME: custom side table allocator //创建sideTable HeapObjectSideTableEntry *side = new HeapObjectSideTableEntry(getHeapObject()); //将创建的地址给到InlineRefCountBits auto newbits = InlineRefCountBits(side); do { if (oldbits.hasSideTable()) { // Already have a side table. Return it and delete ours. // Read before delete to streamline barriers. auto result = oldbits.getSideTable(); delete side; return result; } else if (failIfDeiniting && oldbits.getIsDeiniting()) { // Already past the start of deinit. Do nothing. return nullptr; } side->initRefCounts(oldbits); } while (! refCounts.compare_exchange_weak(oldbits, newbits, std::memory_order_release, std::memory_order_relaxed)); return side; } ``` - 先拿到原本的引用计数 - 散列表也需要存储强引用的引用计数 - 如果这个bits本来就有散列表了，就直接使用原有的散列表 - 创建散列表（通过allocateSideTable构建散列表） - 这个散列表只是针对当前对象的 - 通过InlineRefCountBits将散列表的地址赋给值newBits - 因此如果有弱引用，那么引用计数中存储的就是散列表地址 **InlineRefCountBits** ```js SWIFT_ALWAYS_INLINE RefCountBitsT(HeapObjectSideTableEntry* side) //将散列表通过地址偏移操作存入RefCountBits中 : bits((reinterpret_cast(side) >> Offsets::SideTableUnusedLowBits) | (BitsType(1) << Offsets::UseSlowRCShift) | (BitsType(1) << Offsets::SideTableMarkShift)) { assert(refcountIsInline); } ``` - 传入的参数是HeapObjectSideTableEntry的方法，就是用来构建散列表的Bits - 将散列表地址通过偏移操作存储到RefCountBits内存中 - 在这里可以看到，除去63、62位，剩下的地方用来存储了散列表地址 **HeapObjectSideTableEntry** ```js class HeapObjectSideTableEntry { // FIXME: does object need to be atomic? std::atomic object; //对象 SideTableRefCounts refCounts; //散列表计数 ... } ``` - 查看散列表的结构 - 包括object和refCounts - 其实可以看做分别将对象和引用计数作为键和值 - 这里的引用计数表就是散列表 **SideTableRefCountBits** ![Xnip2023-12-18_20-03-01.jpg](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/6138a44d3ea74e1da5965cf2b5f53f46~tplv-k3u1fbpfcp-jj-mark:0:0:0:0:q75.image#?w=687&h=115&s=53757&e=jpg&b=1e1e1e) - 继承自RefCountBitsT - 只有一个属性weakBits，是弱引用属性 - 在RefCountBitsT中还有一个属性，64位用来记录原有的强引用计数。 **验证** ![16621357838486.jpg](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/87d01e8be37d4230898df0ee02162cad~tplv-k3u1fbpfcp-jj-mark:0:0:0:0:q75.image#?w=600&h=710&s=37684&e=webp&b=1f2125) 计算过程 ![Kapture 2022-09-03 at 00.20.22.gif](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/cf24170f3a374e6489f687c5b8bf5f0b~tplv-k3u1fbpfcp-jj-mark:0:0:0:0:q75.image#?w=592&h=732&s=1667694&e=webp&f=245&b=27262d) - 散列表地址 = refCounts 清除63、62位 + 左移三位 - 上面我们拿到了弱引用后的地址0xc000000020261de6 - 将62、63清零，变成0x20261DE6 - 然后左移3位变成0x10130EF30，这个就是散列表地址 - 查看散列表内容 - 包含两个内容，一个是对象，所以会打印对象的地址 - 一个是引用表，引用表包含强引用计数和弱引用计数 **总结弱引用：** - 当给一个对象增加弱引用后，会创建一个散列表用来存储弱引用和强引用 - 并且将散列表的地址存储到bits中 # 整体总结 - 值类型都是神拷贝操作 - HeapObject有两种refCounts方式 - 没有弱引用 - 没有弱引用，只有强引用和无主引用 - strongCount + unonwnedCount - 有弱引用 - 如果有弱引用，那么存储的是一个散列表地址 - 而散列表中存储的是object和散列表信息 - 散列表信息又包含了weakBits - 同时又因为继承RefCountBitsT，所以依然会包含强引用和无主引用。 **到这里就完毕了，感谢您的阅读，欢迎阅读我的其他文章！**