Runtime之对象的一生

NSString *str = [[NSString alloc] init];

NSString *str = [NSString new];

NSMutableString *str = [NSMutableString string];

+ (id)alloc {
return _objc_rootAlloc(self);
}

id
_objc_rootAlloc(Class cls)
{
return callAlloc(cls, false/*checkNil*/, true/*allocWithZone*/);
}

// ALWAYS_INLINE 强制内联函数 所有加了__attribute__((always_inline))的函数再
// 把被调用时不会被编译成函数调用而是直接扩展到调用函数体内
static ALWAYS_INLINE id
callAlloc(Class cls, bool checkNil, bool allocWithZone=false)
{
// slowpath 表示if条件为0的可能性较大 利于编译器优化指令跳转
// 如果需要检查nil 且cls 为nil 那么直接返回nil
// 因此 如果cls不存在使用alloc方法创建时可能返回nil
if (slowpath(checkNil && !cls)) return nil;
#if __OBJC2__
// fastpath 表示if条件中为1的可能性较大
// 如果类没有自定义的allocwithzone方法
if (fastpath(!cls->ISA()->hasCustomAWZ())) {
// cls 是否可以快速创建
if (fastpath(cls->canAllocFast())) {
// No ctors, raw isa, etc. Go straight to the metal.
// cls是否有c++销毁方法 dtor = destructor
bool dtor = cls->hasCxxDtor();
// calloc 在内存中动态地分配 1 个长度为  cls->bits.fastInstanceSize() 的连续空间
id obj = (id)calloc(1, cls->bits.fastInstanceSize());
// 如果obj为空 类初始化失败 报错 attempt to allocate object of class '%s' failed
if (slowpath(!obj)) return callBadAllocHandler(cls);
// 调用初始化对象isa方法
obj->initInstanceIsa(cls, dtor);
return obj;
}
else {
// Has ctor or raw isa or something. Use the slower path.
// 调用class_createInstance创建对象
id obj = class_createInstance(cls, 0);
// 如果对象为空 那么直接报错
if (slowpath(!obj)) return callBadAllocHandler(cls);
return obj;
}
}
#endif
// No shortcuts available.
// alloc 方法会进一步调用allocwithzone方法
if (allocWithZone) return [cls allocWithZone:nil];
// 正常情况不会走到这里 想到与一个递归？
return [cls alloc];
}

static ALWAYS_INLINE id
callAlloc(Class cls, bool checkNil, bool allocWithZone=false)
{
#if __OBJC2__
if (slowpath(checkNil && !cls)) return nil;
// 是否有自定义的allocWithZone方法
if (fastpath(!cls->ISA()->hasCustomAWZ())) {
// 直接调用_objc_rootAllocWithZone
return _objc_rootAllocWithZone(cls, nil);
}
#endif
// No shortcuts available.
// 是否需要调用allocWithZone _objc_rootAlloc方法调用时这个参数为yes
if (allocWithZone) {
return ((id(*)(id, SEL, struct _NSZone *))objc_msgSend)(cls, @selector(allocWithZone:), nil);
}
// 调用alloc方法
return ((id(*)(id, SEL))objc_msgSend)(cls, @selector(alloc));
}

//allocWithZone的根方法
id
_objc_rootAllocWithZone(Class cls, malloc_zone_t *zone)
{
id obj;
// 如果zone未空 那么直接调用class_createInstance方法 与之前750的实现一致
if (fastpath(!zone)) {
obj = class_createInstance(cls, 0);
} else {
// 如果返回的zone有值 那么调用class_createInstanceFromZone传入
obj = class_createInstanceFromZone(cls, 0, zone);
}
// 如果创建的obj为空
if (slowpath(!obj)) obj = _objc_callBadAllocHandler(cls);
return obj;
}

id
class_createInstance(Class cls, size_t extraBytes)
{
if (!cls) return nil;
return _class_createInstanceFromZone(cls, extraBytes, nil);
}

NEVER_INLINE
id
_objc_rootAllocWithZone(Class cls, malloc_zone_t *zone __unused)
{
// allocWithZone under __OBJC2__ ignores the zone parameter
return _class_createInstanceFromZone(cls, 0, nil,
OBJECT_CONSTRUCT_CALL_BADALLOC);
}

// 创建对象
// cls 创建对象的类型
// extraBytes 额外字节 正常alloc方法这个值为0
// zone construct_flags outAllocatedSize
static ALWAYS_INLINE id
_class_createInstanceFromZone(Class cls, size_t extraBytes, void *zone,
int construct_flags = OBJECT_CONSTRUCT_NONE,
bool cxxConstruct = true,
size_t *outAllocatedSize = nil)
{
ASSERT(cls->isRealized());
// Read class's info bits all at once for performance
// 是否有自定义的创建方法
bool hasCxxCtor = cxxConstruct && cls->hasCxxCtor();
// 是否有自定义的销毁方法
bool hasCxxDtor = cls->hasCxxDtor();
// canAllocNonpointer:class's instances requires raw isa
// #define FAST_CACHE_REQUIRES_RAW_ISA   (1<<13)
// 是否是 isa_t 类型的 isa
bool fast = cls->canAllocNonpointer();
size_t size;
// 增加额外字节
size = cls->instanceSize(extraBytes);
if (outAllocatedSize) *outAllocatedSize = size;
id obj;
// 新创建一个obj 并指向一块新创建的内存空间
if (zone) {
obj = (id)malloc_zone_calloc((malloc_zone_t *)zone, 1, size);
} else {
obj = (id)calloc(1, size);
}
// 如果对象创建失败 obj = nil
if (slowpath(!obj)) {
if (construct_flags & OBJECT_CONSTRUCT_CALL_BADALLOC) {
return _objc_callBadAllocHandler(cls);
}
return nil;
}
// isa如果是isa_t类型
if (!zone && fast) {
obj->initInstanceIsa(cls, hasCxxDtor);
} else {
// Use raw pointer isa on the assumption that they might be
// doing something weird with the zone or RR.
// isa是cls类型
obj->initIsa(cls);
}
// 如果没有自定义构建方法
if (fastpath(!hasCxxCtor)) {
return obj;
}
// 自定义构建方法调用
construct_flags |= OBJECT_CONSTRUCT_FREE_ONFAILURE;
return object_cxxConstructFromClass(obj, cls, construct_flags);
}

bool hasCxxDtor() {
// addSubclass() propagates this flag from the superclass.
assert(isRealized());
return bits.hasCxxDtor();
}
bool hasCxxDtor() {
return data()->flags & RW_HAS_CXX_DTOR;
}
// class or superclass has .cxx_destruct implementation
#define RW_HAS_CXX_DTOR       (1<<17)

BOOL canAllocNonpointer() {
ASSERT(!isFuture());
return !instancesRequireRawIsa();
}
BOOL instancesRequireRawIsa() {
return cache.getBit(FAST_CACHE_REQUIRES_RAW_ISA);
}
// class's instances requires raw isa
#define FAST_CACHE_REQUIRES_RAW_ISA   (1<<13)

inline void
objc_object::initInstanceIsa(Class cls, bool hasCxxDtor)
{
assert(!cls->instancesRequireRawIsa());
assert(hasCxxDtor == cls->hasCxxDtor());
// 相当于也是包装了一层
initIsa(cls, true, hasCxxDtor);
}

inline void
objc_object::initIsa(Class cls, bool nonpointer, bool hasCxxDtor)
{
ASSERT(!isTaggedPointer());
// 如果是非isa_t类型 直接返回 这个cls即可 因为isa中只有一个指针指向isa
if (!nonpointer) {
isa = isa_t((uintptr_t)cls);
} else {
ASSERT(!DisableNonpointerIsa);
ASSERT(!cls->instancesRequireRawIsa());
// 创建 isa_t 类型临时变量
isa_t newisa(0);
// 配置 magic 表示当前对象已经创建
// 配置 nonpointer 表示当前对象的 isa 为 isa_t 类型的
newisa.bits = ISA_MAGIC_VALUE;
// isa.magic is part of ISA_MAGIC_VALUE
// isa.nonpointer is part of ISA_MAGIC_VALUE
// 配置 has_cxx_dtor 表示当前对象是否有 C++ 的析构器
newisa.has_cxx_dtor = hasCxxDtor;
// 配置 shiftcls 指向类对象，右移了 3 位是因为类的指针是按照字节（8bits）对齐的，
// 其指针后三位都是没有意义的 0，因此可以右移 3 位进行消除，以减小无意义的内存占用。
newisa.shiftcls = (uintptr_t)cls >> 3;
// 将临时变量赋值给结构体成员
isa = newisa;
}
}

bool hasCustomAWZ() {
return ! bits.hasDefaultAWZ();
}
bool hasDefaultAWZ() {
return data()->flags & RW_HAS_DEFAULT_AWZ;
}
// class or superclass has default alloc/allocWithZone: implementation
// Note this is is stored in the metaclass.
#define RW_HAS_DEFAULT_AWZ    (1<<16)

// 递归调用对象的C++构造方法，从基类到子类的构造方法
id
object_cxxConstructFromClass(id obj, Class cls, int flags)
{
ASSERT(cls->hasCxxCtor());  // required for performance, not correctness
id (*ctor)(id);
Class supercls;
supercls = cls->superclass;
// Call superclasses' ctors first, if any.
// 如果父类有C++构造方法
if (supercls  &&  supercls->hasCxxCtor()) {
// 调用父类构造方法
bool ok = object_cxxConstructFromClass(obj, supercls, flags);
// 父类构造方法失败 返回nil
if (slowpath(!ok)) return nil;  // some superclass's ctor failed - give up
}
// Find this class's ctor, if any.
// 父类构造方法调用完成后调用当前类的SEL_cxx_construct方法
ctor = (id(*)(id))lookupMethodInClassAndLoadCache(cls, SEL_cxx_construct);
// 如果当前类的构造为转发方法 那么直接返回 表示没有对应实现
if (ctor == (id(*)(id))_objc_msgForward_impcache) return obj;  // no ctor - ok
// Call this class's ctor.
if (PrintCxxCtors) {
_objc_inform("CXX: calling C++ constructors for class %s",
cls->nameForLogging());
}
// 调用构造方法 传入参数obj
if (fastpath((*ctor)(obj))) return obj;  // ctor called and succeeded - ok
supercls = cls->superclass; // this reload avoids a spill on the stack
// This class's ctor was called and failed.
// Call superclasses's dtors to clean up.
if (supercls) object_cxxDestructFromClass(obj, supercls);
if (flags & OBJECT_CONSTRUCT_FREE_ONFAILURE) free(obj);
if (flags & OBJECT_CONSTRUCT_CALL_BADALLOC) {
return _objc_callBadAllocHandler(cls);
}
return nil;
}

// Replaced by ObjectAlloc
+ (id)allocWithZone:(struct _NSZone *)zone {
return _objc_rootAllocWithZone(self, (malloc_zone_t *)zone);
}

if (slowpath(checkNil && !cls)) return nil;
// 是否有自定义的allocWithZone方法
if (fastpath(!cls->ISA()->hasCustomAWZ())) {
// 直接调用_objc_rootAllocWithZone
return _objc_rootAllocWithZone(cls, nil);
}

- (id)init {
return _objc_rootInit(self);
}

id
_objc_rootInit(id obj)
{
// In practice, it will be hard to rely on this function.
// Many classes do not properly chain -init calls.
return obj;
}

+ (id)new {
return [callAlloc(self, false/*checkNil*/) init];
}

Person *person = [[Person alloc] init];
Person *personCpy = [person copy];

/*
"Unknown" includes non-object ivars and non-ARC non-__weak ivars
"Strong" includes ARC __strong ivars
"Weak" includes ARC and new MRC __weak ivars
"Unretained" includes ARC __unsafe_unretained and old GC+MRC __weak ivars
*/
typedef enum {
objc_ivar_memoryUnknown,     // unknown / unknown
objc_ivar_memoryStrong,      // direct access / objc_storeStrong
objc_ivar_memoryWeak,        // objc_loadWeak[Retained] / objc_storeWeak
objc_ivar_memoryUnretained   // direct access / direct access
} objc_ivar_memory_management_t;

Person *stu = [[Person alloc] init];

__strong Person *stu = [[Person alloc] init];

void
objc_storeStrong(id *location, id obj)
{
id prev = *location;
// 先判断之前的值和要新赋值的对象地址是否相同
if (obj == prev) {
return;
}
// 执行retain操作 保留新值
objc_retain(obj);
*location = obj;
// 释放旧值
objc_release(prev);
}

__attribute__((aligned(16), flatten, noinline))
id
objc_retain(id obj)
{
// 如果为nil 直接返回nil
if (!obj) return obj;
// 如果是taggedPointer 直接返回
if (obj->isTaggedPointer()) return obj;
// 调用retain方法
return obj->retain();
}

// 等价于直接使用对象调用retain方法
inline id
objc_object::retain()
{
// 如果是TaggedPointer类型 不涉及引用计数
ASSERT(!isTaggedPointer());
// fastpath 表示if中的条件是一个大概率事件
// 如果当前对象没有自定义（override）retain 方法
if (fastpath(!ISA()->hasCustomRR())) {
return rootRetain();
}
// 如果有自定义的retain方法
// 通过发消息的方式调用自定义的 retain 方法
return ((id(*)(objc_object *, SEL))objc_msgSend)(this, @selector(retain));
}

// location weak指针自身的地址
// newObj weak指针指向的新对象的地址
id
objc_storeWeak(id *location, id newObj)
{
return storeWeak<DoHaveOld, DoHaveNew, DoCrashIfDeallocating>
(location, (objc_object *)newObj);

- (NSUInteger)retainCount {
return _objc_rootRetainCount(self);
}
uintptr_t
_objc_rootRetainCount(id obj)
{
ASSERT(obj);
return obj->rootRetainCount();
}

// 获取引用高技术
inline uintptr_t
objc_object::rootRetainCount()
{
//isTaggedPointer 不需要引用计数
if (isTaggedPointer()) return (uintptr_t)this;
sidetable_lock();
isa_t bits = LoadExclusive(&isa.bits);
ClearExclusive(&isa.bits);
// 如果是nonpointer
if (bits.nonpointer) {
// 先从extra_rc取出部分引用计数
uintptr_t rc = 1 + bits.extra_rc;
// sidetable中是否有额外的引用计数
if (bits.has_sidetable_rc) {
// 从sidetable中获取引用计数
rc += sidetable_getExtraRC_nolock();
}
sidetable_unlock();
return rc;
}
sidetable_unlock();
// 如果不是nonpointer 直接从sidetable中获取引用计数
return sidetable_retainCount();
}

- (oneway void)release {
_objc_rootRelease(self);
}

NEVER_INLINE void
_objc_rootRelease(id obj)
{
ASSERT(obj);
obj->rootRelease();
}

- (id)autorelease {
return _objc_rootAutorelease(self);
}

__attribute__((noinline,used))
id
objc_object::rootAutorelease2()
{
ASSERT(!isTaggedPointer());
return AutoreleasePoolPage::autorelease((id)this);
}
static inline id autorelease(id obj)
{
ASSERT(obj);
ASSERT(!obj->isTaggedPointer());
id *dest __unused = autoreleaseFast(obj);
ASSERT(!dest  ||  dest == EMPTY_POOL_PLACEHOLDER  ||  *dest == obj);
return obj;
}
static inline id *autoreleaseFast(id obj)
{
AutoreleasePoolPage *page = hotPage();
if (page && !page->full()) {
return page->add(obj);
} else if (page) {
return autoreleaseFullPage(obj, page);
} else {
return autoreleaseNoPage(obj);
}
}

- (void)dealloc {
_objc_rootDealloc(self);
}
_objc_rootDealloc(id obj)
{
ASSERT(obj);
obj->rootDealloc();
}
inline void
objc_object::rootDealloc()
{
if (isTaggedPointer()) return;  // fixme necessary?
if (fastpath(isa.nonpointer  &&
!isa.weakly_referenced  &&
!isa.has_assoc  &&
!isa.has_cxx_dtor  &&
!isa.has_sidetable_rc))
{
assert(!sidetable_present());
free(this);
}
else {
object_dispose((id)this);
}
}

static id
_object_dispose(id anObject)
{
if (anObject==nil) return nil;
// 调用objc_destructInstance
objc_destructInstance(anObject);
// isa指针为_objc_getFreedObjectClass类型
anObject->initIsa(_objc_getFreedObjectClass ());
// 释放对象
free(anObject);
return nil;
}

// 对象的析构方法
void *objc_destructInstance(id obj)
{
if (obj) {
// 获取到isa
Class isa = obj->getIsa();
// 是否有c++析构方法 有则执行
if (isa->hasCxxDtor()) {
object_cxxDestruct(obj);
}
// 是否有关联对象 有则移除
if (isa->instancesHaveAssociatedObjects()) {
_object_remove_assocations(obj);
}
// 调用objc_clear_deallocating方法
objc_clear_deallocating(obj);
}
return obj;
}

/***********************************************************************
* _class_getFreedObjectClass.  Return a pointer to the dummy freed
* object class.  Freed objects get their isa pointers replaced with
* a pointer to the freedObjectClass, so that we can catch usages of
* the freed object.
**********************************************************************/
static Class _class_getFreedObjectClass(void)
{
return (Class)freedObjectClass;
}

if (anObject->ISA() == _objc_getFreedObjectClass ())
__objc_error(anObject, "reallocating freed object");

inline void
objc_object::clearDeallocating()
{
if (slowpath(!isa.nonpointer)) {
// Slow path for raw pointer isa.
sidetable_clearDeallocating();
}
else if (slowpath(isa.weakly_referenced  ||  isa.has_sidetable_rc)) {
// Slow path for non-pointer isa with weak refs and/or side table data.
clearDeallocating_slow();
}
assert(!sidetable_present());
}

void
objc_object::sidetable_clearDeallocating()
{
SideTable& table = SideTables()[this];
// clear any weak table items
// clear extra retain count and deallocating bit
// (fixme warn or abort if extra retain count == 0 ?)
table.lock();
RefcountMap::iterator it = table.refcnts.find(this);
if (it != table.refcnts.end()) {
if (it->second & SIDE_TABLE_WEAKLY_REFERENCED) {
weak_clear_no_lock(&table.weak_table, (id)this);
}
table.refcnts.erase(it);
}
table.unlock();
}

NEVER_INLINE void
objc_object::clearDeallocating_slow()
{
ASSERT(isa.nonpointer  &&  (isa.weakly_referenced || isa.has_sidetable_rc));
SideTable& table = SideTables()[this];
table.lock();
if (isa.weakly_referenced) {
weak_clear_no_lock(&table.weak_table, (id)this);
}
if (isa.has_sidetable_rc) {
table.refcnts.erase(this);
}
table.unlock();
}