OC底层文章汇总

在OC底层探索(十八)内存五大区中了解了栈区、堆区、全局区、常量区和代码区五大区的分布，那么今天来分析一下内存管理的引用计数。

taggedpointer小对象类型

在iOS中NSNumber、NSString都是有小对象组成的对象，存放在栈区,并且占用空间非常的小。

在分析ISA、cache、read_image和sendMessage时都提及到了小对象类型。

分析

• 在_read_images中可以看到initializeTaggedPointerObfuscator方法，当时并没有分析，这是一步是进行初始化小对象类型。

• 查看initializeTaggedPointerObfuscator

  • 在iOS14时，发现苹果将小对象类型的指针地址进行了混淆。

static void
initializeTaggedPointerObfuscator(void)
{if (sdkIsOlderThan(10_14, 12_0, 12_0, 5_0, 3_0) ||// Set the obfuscator to zero for apps linked against older SDKs,// in case they're relying on the tagged pointer representation.DisableTaggedPointerObfuscation) {objc_debug_taggedpointer_obfuscator = 0;} else {// Pull random data into the variable, then shift away all non-payload bits.arc4random_buf(&objc_debug_taggedpointer_obfuscator,sizeof(objc_debug_taggedpointer_obfuscator));objc_debug_taggedpointer_obfuscator &= ~_OBJC_TAG_MASK;}
}

• 在源码中发现了_objc_decodeTaggedPointer和_objc_taggedPointersEnabled，分别是对小对象类型进行加密与解密，即执行异或操作。

static inline uintptr_t
_objc_decodeTaggedPointer(const void * _Nullable ptr)
{return (uintptr_t)ptr ^ objc_debug_taggedpointer_obfuscator;
}static inline bool 
_objc_taggedPointersEnabled(void)
{extern uintptr_t objc_debug_taggedpointer_mask;return (objc_debug_taggedpointer_mask != 0);
}

• 分别写NSString和NSNumber变量，并进行解密查看其地址。

NSNumber *number1 = @1;
NSString *str2 = [NSString stringWithFormat:@"b"];NSLog(@"%@-%p-%@",object_getClass(number1),number1,number1);
NSLog(@"%@-%p-%@ - 0x%lx",object_getClass(number1),number1,number1,_objc_decodeTaggedPointer_(number1));
NSLog(@"%p-%@",str2,str2);NSLog(@"0x%lx",_objc_decodeTaggedPointer_(str2));

打印结果为：

• _objc_isTaggedPointer中是进行判断是否为小对象类型，地址直接是对_OBJC_TAG_MASK进行与运算进行判断，其中_OBJC_TAG_MASK是1 左移 63位，就是判断最高位是否为1，如果是1那么就是小对象类型。

static inline bool 
_objc_isTaggedPointer(const void * _Nullable ptr)
{return ((uintptr_t)ptr & _OBJC_TAG_MASK) == _OBJC_TAG_MASK;
}

 define _OBJC_TAG_MASK (1UL<<63)

• 其中小对象的类型是由地址的高2~4位决定的，其中010 => 2 代表的是NSString，011 => 3代表的是NSNumber.

• 分析0xb000000000000012、0xa000000000000621

  • 0xa => 1011 最高位1代表的是小对象类型，011代表的是NSNumber类型
  • 0xb => 1010 最高位1代表的是小对象类型，010代表的是NSString类型

小结：

• Tagged Pointer专⻔用来存储小的对象，例如NSNumber和NSDate

• Tagged Pointer 指针的值不再是地址了，而是真正的值。所以，实际上它不再 是一个对象了，它只是一个披着对象皮的普通变量而已。所以，它的内存并不存储 在堆中，所以retain 和 release 没有对小对象类型进行内存管理,即可以自主回收

• 在内存读取上有着3倍的效率，创建时比以前快106倍。

SiddeTables散列表

在NONPOINTER_ISA中引用计数是存储在extra_rc中，但是如果当这里面存满了，那么就向SiddeTables中存储.

• 应用中存在多张散列表

• 每张散列表中都存放着自旋锁、引用计数和弱引用表.

源码分析

• SideTable是存在到SideTablesMap (hash表)中

static StripedMap<SideTable>& SideTables() {return SideTablesMap.get();
}

• 在StripedMap中我们发现SideTable会有多张，

  • 真机最多有8张散列表
  • 模拟器最多有64张散列表

class StripedMap {
#if TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR//真机、非模拟器enum { StripeCount = 8 };
#elseenum { StripeCount = 64 };
#endifstruct PaddedT {T value alignas(CacheLineSize);};PaddedT array[StripeCount];static unsigned int indexForPointer(const void *p) {uintptr_t addr = reinterpret_cast<uintptr_t>(p);return ((addr >> 4) ^ (addr >> 9)) % StripeCount;}public:T& operator[] (const void *p) { return array[indexForPointer(p)].value; }const T& operator[] (const void *p) const { return const_cast<StripedMap<T>>(this)[p]; }......
};

• SideTable是一个结构体，分别存放着spinlock_t、RefcountMap和`weak_table_t类型的属性。

struct SideTable {spinlock_t slock;//自旋锁RefcountMap refcnts;//引用计数weak_table_t weak_table;//弱引用表SideTable() {memset(&weak_table, 0, sizeof(weak_table));}~SideTable() {_objc_fatal("Do not delete SideTable.");}void lock() { slock.lock(); }void unlock() { slock.unlock(); }void forceReset() { slock.forceReset(); }// Address-ordered lock discipline for a pair of side tables.template<HaveOld, HaveNew>static void lockTwo(SideTable *lock1, SideTable *lock2);template<HaveOld, HaveNew>static void unlockTwo(SideTable *lock1, SideTable *lock2);
};

retain 引用计数加一

• 搜索objc_retain，发现在源码中，对小对象类型进行了判断，如果是小对象类型就直接返回该对象，没有进行引用计数加一。

__attribute__((aligned(16), flatten, noinline))
id 
objc_retain(id obj)
{if (!obj) return obj;if (obj->isTaggedPointer()) return obj;return obj->retain();
}

• 进入retain，查看rootRetain

inline id 
objc_object::retain()
{ASSERT(!isTaggedPointer());if (fastpath(!ISA()->hasCustomRR())) {return rootRetain();}return ((id(*)(objc_object *, SEL))objc_msgSend)(this, @selector(retain));
}

• 查看rootRetain

ALWAYS_INLINE id 
objc_object::rootRetain(bool tryRetain, bool handleOverflow)
{if (isTaggedPointer()) return (id)this;bool sideTableLocked = false;bool transcribeToSideTable = false;isa_t oldisa;isa_t newisa;do {transcribeToSideTable = false;oldisa = LoadExclusive(&isa.bits);newisa = oldisa;//判断是否为nonpointerISA，if (slowpath(!newisa.nonpointer)) {//不是nonpointerISA直接操作散列表ClearExclusive(&isa.bits);if (rawISA()->isMetaClass()) return (id)this;if (!tryRetain && sideTableLocked) sidetable_unlock();if (tryRetain) return sidetable_tryRetain() ? (id)this : nil;else return sidetable_retain();}// don't check newisa.fast_rr; we already called any RR overrides//判断是否正在析构if (slowpath(tryRetain && newisa.deallocating)) {ClearExclusive(&isa.bits);if (!tryRetain && sideTableLocked) sidetable_unlock();return nil;}uintptr_t carry;//newisa的bits 加一,其中carrynewisa.bits = addc(newisa.bits, RC_ONE, 0, &carry);  // extra_rc++//如果isa中引用计数满了就操作散列表，直接将extra_rc的一半存储到散列表中if (slowpath(carry)) {// newisa.extra_rc++ overflowedif (!handleOverflow) {ClearExclusive(&isa.bits);return rootRetain_overflow(tryRetain);}// Leave half of the retain counts inline and // prepare to copy the other half to the side table.if (!tryRetain && !sideTableLocked) sidetable_lock();sideTableLocked = true;transcribeToSideTable = true;newisa.extra_rc = RC_HALF;newisa.has_sidetable_rc = true;}} while (slowpath(!StoreExclusive(&isa.bits, oldisa.bits, newisa.bits)));if (slowpath(transcribeToSideTable)) {// Copy the other half of the retain counts to the side table.sidetable_addExtraRC_nolock(RC_HALF);}if (slowpath(!tryRetain && sideTableLocked)) sidetable_unlock();return (id)this;
}

retain操作流程

• 判断是否为nonpointerISA

  • 是nonpointerISA,直接操作散列表

  • 不是nonpointerISA，在进行判断是否当前对象是否正在释放

    • 正在释放：直接返回,不进行操作

    • 没有在释放，引用计数 加一，存储到isa的extra_rc中，如果extra_rc 满了，就将其中一半存储到散列表中。

realse 引用计数减一

其实就是retain的反流程，有待完善

retainCount

有待完善