当前位置：首页 > news >正文

iOS 内存管理机制与原理

news 文章来源：https://blog.csdn.net/wywinstonwy/article/details/129949464 2025/5/5 4:58:39

内存分区

内存一般分为五大区：栈区、堆区、常量区、全局区、代码区。如图

1.栈区

是由编译器自动分配并释放的，主要用来存储局部变量、函数的参数等，是一块连续的内存区域，遵循先进后出（FILO）原则。一般在运行时分配。它的分配由高地址空间向低地址空间分配。

优点：因为栈是由编译器自动分配并释放的，不会产生内存碎片，所以快速高效。
缺点：栈的内存大小有限制，数据不灵活。

例如：下图，创建两个变量，存放在栈区，地址是递减4。

2.堆区

堆区是由程序员手动管理。主要用来存放动态分配的对象类型数据。是不连续的内存区域。在MRC环境下，由程序员手动释放，在ARC环境下，由编译器自动释放。一般在运行时分配。它的分配是从低地址空间向高地址空间分配。
优点：灵活方便，数据适应面广泛。
缺点：需手动管理，速度慢、容易产生内存碎片。

例如：下图，创建两个对象，存放在堆区，地址递增。

3.常量区

常量区存放的就是字符串常量和基本类型常量。在编译时分配，程序结束后回收

4.全局区/静态区

全局变量和静态变量的存储是放在一起的，初始化的全局变量和静态变量存放在.data段，未初始化的全局变量和静态变量在相邻的.bss区域，在编译时分配，程序结束后由系统释放。

5.代码区

代码区是在编译时分配，主要用于存放程序运行时的代码,代码会被编译成二进制存进内存的

内存管理

内存管理方案

1.TaggedPointer

2013 年 9 月苹果推出了首个采用 64 位架构的 A7 双核处理器的手机 iPhone5s，为了改进从 32 位 CPU 迁移到 64 位的内存浪费和效率问题，在 64 位环境下，苹果工程师提出了 Tagged Pointer 的概念。采用这一机制，系统会对 NSString、NSNumber 和 NSDate 等对象进行优化。建议大家看看 WWDC2020 这个视频的介绍。

Tagged Pointer 专门用来存储小对象，例如NSNumber，NSDate等，Tagged Pointer指针的值不再是单纯的地址了，而是真正的值，所以，实际上它也不再是一个对象了，它只是一个披着对象皮的普通变量而已，所以它的内存并不存储在堆区，也不需要malloc和free。这样在读取上有着3倍的效率，创建时候比以前快106倍。

由上图可以看出NSdate是NSTaggedPointer，此外当字符串的长度为10个以内时，字符串的类型都是NSTaggedPointerString类型，当超过10个时，字符串的类型才是__NSCFString

NSTaggedPointer标志位

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

上面这个方法我们看到，判断一个对象类型是否为NSTaggedPointerString类型实际上是讲对象的地址与_OBJC_TAG_MASK进行按位与操作,结果在跟_OBJC_TAG_MASK进行对比,我们在看下_OBJC_TAG_MASK的定义:

#if OBJC_MSB_TAGGED_POINTERS
#   define _OBJC_TAG_MASK (1UL<<63)
#else
#   define _OBJC_TAG_MASK 1UL
#endif

我们都知道一个对象地址为64位二进制，它表明如果64位数据中，最高位是1的话，则表明当前是一个tagged pointer类型。

那么我们在看下上面打印出的地址，所有NSTaggedPointerString地址都是0xd开头，d转换为二进制1110，根据上面的结论，我们看到首位为1表示为NSTaggedPointerString类型。在这里得到验证。

注意:TaggedPointer类型在iOS和MacOS中标志位是不同的iOS为最高位而MacOS为最低位

对象类型

正常情况下一个对象的类型，是通过这个对象的ISA指针来判断的，那么对于NSTaggedPointer类型我们如何通过地址判断对应数据是什么类型的呢？

在objc4-723之前，我们可以通过与判断TaggedPointer标志位一样根据地址来判断，而类型的标志位就是对象地址的61-63位,比如对象地址为0xa开头，那么转换成二进制位1010,那么去掉最高位标志位后，剩余为010,即10进制中的2。

接着我们看下runtime源码objc-internal.h中有关于标志位的定义如下：

#if __has_feature(objc_fixed_enum)  ||  __cplusplus >= 201103L
enum objc_tag_index_t : uint16_t
#else
typedef uint16_t objc_tag_index_t;
enum
#endif
{// 60-bit payloadsOBJC_TAG_NSAtom            = 0, OBJC_TAG_1                 = 1, OBJC_TAG_NSString          = 2, OBJC_TAG_NSNumber          = 3, OBJC_TAG_NSIndexPath       = 4, OBJC_TAG_NSManagedObjectID = 5, OBJC_TAG_NSDate            = 6,// 60-bit reservedOBJC_TAG_RESERVED_7        = 7, // 52-bit payloadsOBJC_TAG_Photos_1          = 8,OBJC_TAG_Photos_2          = 9,OBJC_TAG_Photos_3          = 10,OBJC_TAG_Photos_4          = 11,OBJC_TAG_XPC_1             = 12,OBJC_TAG_XPC_2             = 13,OBJC_TAG_XPC_3             = 14,OBJC_TAG_XPC_4             = 15,OBJC_TAG_First60BitPayload = 0, OBJC_TAG_Last60BitPayload  = 6, OBJC_TAG_First52BitPayload = 8, OBJC_TAG_Last52BitPayload  = 263, OBJC_TAG_RESERVED_264      = 264
};
#if __has_feature(objc_fixed_enum)  &&  !defined(__cplusplus)
typedef enum objc_tag_index_t objc_tag_index_t;
#endif

objc4-750之后

// Returns a pointer to the class's storage in the tagged class arrays.
// Assumes the tag is a valid basic tag.
static Class *
classSlotForBasicTagIndex(objc_tag_index_t tag)
{uintptr_t tagObfuscator = ((objc_debug_taggedpointer_obfuscator>> _OBJC_TAG_INDEX_SHIFT)& _OBJC_TAG_INDEX_MASK);uintptr_t obfuscatedTag = tag ^ tagObfuscator;// Array index in objc_tag_classes includes the tagged bit itself
#if SUPPORT_MSB_TAGGED_POINTERS 高位优先return &objc_tag_classes[0x8 | obfuscatedTag];
#elsereturn &objc_tag_classes[(obfuscatedTag << 1) | 1];
#endif
}

classSlotForBasicTagIndex() 函数的主要功能就是根据指定索引 tag 从数组objc_tag_classes中获取类指针,而下标的计算方法发是根据外部传递的索引tag。比如字符串 tag = 2。当然这并不是简单的从数组中获取某条数据。

获取TaggedPointer的值

objc4-750之后源码：

static inline uintptr_t
_objc_decodeTaggedPointer(const void * _Nullable ptr)
{return (uintptr_t)ptr ^ objc_debug_taggedpointer_obfuscator;
}static inline uintptr_t
_objc_getTaggedPointerValue(const void * _Nullable ptr) 
{// assert(_objc_isTaggedPointer(ptr));uintptr_t value = _objc_decodeTaggedPointer(ptr);uintptr_t basicTag = (value >> _OBJC_TAG_INDEX_SHIFT) & _OBJC_TAG_INDEX_MASK;if (basicTag == _OBJC_TAG_INDEX_MASK) {return (value << _OBJC_TAG_EXT_PAYLOAD_LSHIFT) >> _OBJC_TAG_EXT_PAYLOAD_RSHIFT;} else {return (value << _OBJC_TAG_PAYLOAD_LSHIFT) >> _OBJC_TAG_PAYLOAD_RSHIFT;}
}static inline intptr_t
_objc_getTaggedPointerSignedValue(const void * _Nullable ptr) 
{// assert(_objc_isTaggedPointer(ptr));uintptr_t value = _objc_decodeTaggedPointer(ptr);uintptr_t basicTag = (value >> _OBJC_TAG_INDEX_SHIFT) & _OBJC_TAG_INDEX_MASK;if (basicTag == _OBJC_TAG_INDEX_MASK) {return ((intptr_t)value << _OBJC_TAG_EXT_PAYLOAD_LSHIFT) >> _OBJC_TAG_EXT_PAYLOAD_RSHIFT;} else {return ((intptr_t)value << _OBJC_TAG_PAYLOAD_LSHIFT) >> _OBJC_TAG_PAYLOAD_RSHIFT;}
}

实例代码和结果

  NSString *str1 = [NSString stringWithFormat:@"1"];NSString *str11 = [NSString stringWithFormat:@"11"];NSString *str2 = [NSString stringWithFormat:@"2"];NSString *str22 = [NSString stringWithFormat:@"22"];// 0x31 1 0x32 1uintptr_t value1 = objc_getTaggedPointerValue((__bridge void *)str1);uintptr_t value2 = objc_getTaggedPointerValue((__bridge void *)str2);uintptr_t value11 = objc_getTaggedPointerValue((__bridge void *)str11);uintptr_t value22 = objc_getTaggedPointerValue((__bridge void *)str22);// 以16进制形式输出NSLog(@"%lx", value1);NSLog(@"%lx", value11);NSLog(@"%lx", value2);NSLog(@"%lx", value22);

TaggedPointer[89535:3033433] 311
TaggedPointer[89535:3033433] 31312
TaggedPointer[89535:3033433] 321
TaggedPointer[89535:3033433] 32322

TaggedPoint对象是一个特殊的对象，不会涉及到引用计数retain、release等内存操作。对象的值就存在指针中，不过值通过了一份加密。

2.NONPOINTER_ISA

上面我们说了，对于一个对象的存储，苹果做了优化，那么对于ISA指针呢？

对象的isa指针，用来表明对象所属的类类型。

union isa_t {isa_t() { }isa_t(uintptr_t value) : bits(value) { }Class cls;uintptr_t bits;
#if defined(ISA_BITFIELD)struct {ISA_BITFIELD;  // defined in isa.h};
#endif
};

结合下图

从图中可以看出，我们所谓的isa指针，最后实际上落脚于isa_t的联合类型。那么何为联合类型呢？ 联合类型是C语言中的一种类型，是一种n选1的关系,联合的作用在于，用更少的空间，表示了更多的可能的类型，虽然这些类型是不能够共存的。比如isa_t 中包含有cls，bits， struct三个变量，它们的内存空间是重叠的。在实际使用时，仅能够使用它们中的一种，你把它当做cls，就不能当bits访问，你把它当bits，就不能用cls来访问。

对于isa_t联合类型，主要包含了两个构造函数isa_t(),isa_t(uintptr_t value)和三个变量cls,bits,struct,而uintptr_t的定义为typedef unsigned long。

当isa_t作为Class cls使用时，这符合了我们之前一贯的认知：isa是一个指向对象所属Class类型的指针。然而，仅让一个64位的指针表示一个类型，显然不划算。

因此，绝大多数情况下，苹果采用了优化的isa策略，即，isa_t类型并不等同而Class cls, 而是struct。

下面我们先来看下struct的结构体

// ISA_BITFIELD定义如下
# if __arm64__
#   define ISA_MASK        0x0000000ffffffff8ULL
#   define ISA_MAGIC_MASK  0x000003f000000001ULL
#   define ISA_MAGIC_VALUE 0x000001a000000001ULL
#   define ISA_BITFIELD                                                      \uintptr_t nonpointer        : 1;                                       \uintptr_t has_assoc         : 1;                                       \uintptr_t has_cxx_dtor      : 1;                                       \uintptr_t shiftcls          : 33; /*MACH_VM_MAX_ADDRESS 0x1000000000*/ \uintptr_t magic             : 6;                                       \uintptr_t weakly_referenced : 1;                                       \uintptr_t deallocating      : 1;                                       \uintptr_t has_sidetable_rc  : 1;                                       \uintptr_t extra_rc          : 19
#   define RC_ONE   (1ULL<<45)
#   define RC_HALF  (1ULL<<18)

注意:成员后面的：表明了该成员占用几个bit 而每个成员的意义如下表

nonopointer：表示是否对isa指针开启了指针优化，

0：纯isa指针，1：不止是类对象地址，isa中包含了类信息，对象的引用计数等。

has_assoc:关联对象标志位，0：没有，1：存在

has_cxx_dtor：该对象是否有c++或者Objc的析构器，如果有析构器函数，则需要做析构逻辑，如果没有，则可以更快的释放。

shiftcls：存储指针的值，开启指针优化的情况下，再arm64架构中有33位用来存储类指针，

magic：用于调试器判断当前对象是真的对象还是未初始化的空间。

weakly_referenced:标致对象是否指向或者曾经指向一个ARC的若变量，没有弱引用的对象可以更快的释放。

deallcating：标志对象是否正在释放内存

has_sidetable_rc：当前对象引用计数大于10的时，则需要借用变量存储进位

extra_rc：当表示该对象的引用计数值，实际上是引用计数值减1，例如，如果对象的引用计数为10，那么extra_rc为9，如果用于计数大于10则需要使用下面的has_sidetable_rc。

3.散列表、引用计数表

Sidetable主要包含spinlock，引用计数(存放extra_rc接收的另一半引用计数)，弱引用表。

truct SideTable {spinlock_t slock;// 存放从extra_rc接收的那一半引用计数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);
};

1.spinlock_t 加锁

spinlock_t 不是自旋锁，在底层代码查找的过程中，我们可以发现他是一把os_unfair_lock锁，在使用sidetable的时候，频繁的读取需要加锁，一张表无疑影响了效率，因此，我们采用stripedMap来分散压力，且stripedMap的数量是根据系统来确定的（真机模式下sidetable最多为8张，虚拟机等为64张).

// 上面 SideTables 的实现
static StripedMap<SideTable>& SideTables() {return SideTablesMap.get();
}

2.RefcountMap(引用计数表)

RefcountMap本身从DenseMap得来

typedef objc::DenseMap<DisguisedPtr<objc_object>,size_t,RefcountMapValuePurgeable> RefcountMap;

存放从extra_rc接收的那一半引用计数

if (variant == RRVariant::Full) {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();
} else {ASSERT(!transcribeToSideTable);ASSERT(!sideTableLocked);
}

接着，来看一下 sidetable_addExtraRC_nolock 方法：

bool 
objc_object::sidetable_addExtraRC_nolock(size_t delta_rc)
{ASSERT(isa.nonpointer);// 获取SideTables,也就是StripeMapSideTable& table = SideTables()[this];size_t& refcntStorage = table.refcnts[this];size_t oldRefcnt = refcntStorage;// isa-side bits should not be set hereASSERT((oldRefcnt & SIDE_TABLE_DEALLOCATING) == 0);ASSERT((oldRefcnt & SIDE_TABLE_WEAKLY_REFERENCED) == 0);if (oldRefcnt & SIDE_TABLE_RC_PINNED) return true;uintptr_t carry;size_t newRefcnt = addc(oldRefcnt, delta_rc << SIDE_TABLE_RC_SHIFT, 0, &carry);if (carry) {refcntStorage =SIDE_TABLE_RC_PINNED | (oldRefcnt & SIDE_TABLE_FLAG_MASK);return true;}else {refcntStorage = newRefcnt;return false;}
}

3.WeakTable（弱引用表）

弱引用底层调用objc_initWeak:

id objc_initWeak(id *location, id newObj)
{if (!newObj) {*location = nil;return nil;}return storeWeak<DontHaveOld, DoHaveNew, DoCrashIfDeallocating>(location, (objc_object*)newObj);
}

storeWeak:

添加引用的时候调用storeWeak一共有五个参数，其中3个参数定义在了template模版参数中（HaveOld:weak指针是否指向一个弱引用；HavNew:weak指针是否需要指向一个新的引用；crashIfDeallocating表示被弱引用的对象是否正在析构）。
weak_unregister_no_lock:清除原来弱引用表中的数据
weak_register_no_lock:将weak的指针地址添加到对象的弱引用表

enum CrashIfDeallocating {DontCrashIfDeallocating = false, DoCrashIfDeallocating = true
};// HaveOld:weak指针是否指向一个弱引用
// HavNew:weak指针是否需要指向一个新的引用
template <HaveOld haveOld, HaveNew haveNew,enum CrashIfDeallocating crashIfDeallocating>
static id 
storeWeak(id *location, objc_object *newObj)
{ASSERT(haveOld  ||  haveNew);if (!haveNew) ASSERT(newObj == nil);Class previouslyInitializedClass = nil;id oldObj;SideTable *oldTable;SideTable *newTable;// Acquire locks for old and new values.// Order by lock address to prevent lock ordering problems. // Retry if the old value changes underneath us.retry:if (haveOld) {//如果有拿到旧表oldObj = *location;oldTable = &SideTables()[oldObj];} else {oldTable = nil;}if (haveNew) {//如果没有创建新表newTable = &SideTables()[newObj];} else {newTable = nil;}SideTable::lockTwo<haveOld, haveNew>(oldTable, newTable);if (haveOld  &&  *location != oldObj) {//如果旧表不存在对应的objSideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);goto retry;}// Prevent a deadlock between the weak reference machinery// and the +initialize machinery by ensuring that no // weakly-referenced object has an un-+initialized isa.if (haveNew  &&  newObj) {//有新表和新对象Class cls = newObj->getIsa();if (cls != previouslyInitializedClass  &&  !((objc_class *)cls)->isInitialized()) //如果类没有初始化就重新初始化{SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);class_initialize(cls, (id)newObj);// If this class is finished with +initialize then we're good.// If this class is still running +initialize on this thread // (i.e. +initialize called storeWeak on an instance of itself)// then we may proceed but it will appear initializing and // not yet initialized to the check above.// Instead set previouslyInitializedClass to recognize it on retry.previouslyInitializedClass = cls;goto retry;}}// Clean up old value, if any.if (haveOld) {//如果指针曾经指向别的对象，就清除// 清除原来弱引用表中数据weak_unregister_no_lock(&oldTable->weak_table, oldObj, location);}// Assign new value, if any.if (haveNew) {newObj = (objc_object *)// 将weak的指针地址添加到对象的弱引用表weak_register_no_lock(&newTable->weak_table, (id)newObj, location, crashIfDeallocating ? CrashIfDeallocating : ReturnNilIfDeallocating);// weak_register_no_lock returns nil if weak store should be rejected// Set is-weakly-referenced bit in refcount table.if (!newObj->isTaggedPointerOrNil()) {// 将对象曾经指向过弱引用的标识置为true,没有弱引用的释放更快newObj->setWeaklyReferenced_nolock();}// Do not set *location anywhere else. That would introduce a race.*location = (id)newObj;}else {// No new value. The storage is not changed.}SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);// This must be called without the locks held, as it can invoke// arbitrary code. In particular, even if _setWeaklyReferenced// is not implemented, resolveInstanceMethod: may be, and may// call back into the weak reference machinery.callSetWeaklyReferenced((id)newObj);return (id)newObj;
}

weak_entry_t:

struct weak_table_t {// 弱引用数组weak_entry_t *weak_entries;// 数组个数size_t    num_entries;uintptr_t mask;uintptr_t max_hash_displacement;
};

weak_entries是一个哈希数组，一个对象可以被多个弱引用指针引用，因此，这里用数组的形式表示一个对象的多个弱引用；数组中存储的内容就是弱引用对象的指针地址。当对象的弱引用个数小于等于4时走静态存储（在weak_entry_t初始化的时候一并分配好），大于4走动态存储。

sidetables总结：

sidetables可以理解为一个全局的hash数组，里面存储了sidetables类型的数据，其中长度为8或者64
一个obj（oc对象）对应了一个sideTable，但是一个SideTable，会对应多个obj，因为sidetabels的数量只有8或者64个，所以有很多obj会共用一个sidetable
在弱引用表中，key是对象的地址，value是weak指针地址的数组（weak_entry_t）
weak_unregister_no_lock 和 weak_register_no_lock 中都是对 weak_entry_t 类型的数组进行操作
_ _weak修饰对象(不会放入自动释放池)，会调用objc_loadWeakRetained；使得引用计数加一，但仅是临时变量；被引用的对象不会增加他的引用计数。

ARC&MRC

Object-C提供了两种内存管理机制MRC（Mannul Reference Counting）和ARC（Automatic Reference Counting），为Objective-C提供了内存的手动和自动管理。

MRC

基本思想：通过手动引用计数来进行对象的内存管理

涉及方法

alloc/new/copy/mutableCopy：生成对象并自己持有，引用计数+1（从0变为1）
retain :持有对象，使对象的引用计数加1
release : 释放对象，使对象的引用计数减1
retainCount : 获取当前对象的引用计数值
autorelease : 当前对象会在autoreleasePool结束的时候,调用这个对象的release操作,进行引用计数减1
dealloc : 在MRC中若调用dealloc，需要显示的调用[super dealloc]，来释放父类的相关成员变量

autorelease

autorelease即“自动释放”，是OC的一种内存自动回收机制，可以将一些临时变量通过自动释放池来回收统一释放。自动释放池销毁的时候，池子里面所有的对象都会做一次release操作

那么，autorelease释放与简单的release释放有什么区别呢？

调用 autorelease 方法，就会把该对象放到离自己最近的自动释放池中（栈顶的释放池，多重自动释放池嵌套是以栈的形式存取的），即：使对象的持有权转移给了自动释放池（即注册到了自动释放池中），调用方拿到了对象，但这个对象还不被调用方所持有。当自动释放池销毁时，其中的所有的对象都会调用一次release操作。

本质上，区别在于autorelease 方法不会改变调用者的引用计数，它只是改变了对象释放时机，不再让程序员负责释放这个对象，而是交给自动释放池去处理。

autorelease 方法相当于把调用者注册到 autoreleasepool 中，ARC环境下不能显式地调用 autorelease 方法和显式地创建 NSAutoreleasePool 对象，但可以使用@autoreleasepool { }块代替（并不代表块中所有内容都被注册到了自动释放池中）。
对于所有调用过autorelease实例方法的对象，在废弃NSAutoreleasePool对象时，都将调用release实例方法。

RunLoop和AutoReleasePool是通过线程的方式一一对应的
在非手动添加Autorelease pool下，Autorelease对象是在当前runloop进入休眠等待前被释放的
当一个runloop在不停的循环工作，那么runloop每一次循环必定会经过BeforeWaiting(准备进入休眠)：而去BeforeWaiting(准备进入休眠) 时会调用_objc_autoreleasePoolPop()和 _objc_autoreleasePoolPush()释放旧的池并创建新池，那么这两个方法来销毁要释放的对象，所以我们根本不需要担心Autorelease的内存管理问题。

ARC

内存管理方案

iOS内存管理方案有：

MRC和ARC
Tagged Pointer:专门用来处理小对象，例如NSNumber、NSDate、小NSString等
NONPOINTER_ISA :非指针类型的isa，主要是用来优化64位地址。在 64 位架构下，isa 指针是占 64 比特位的，实际上只有 30 多位就已经够用了，为了提高利用率，剩余的比特位存储了内存管理的相关数据内容。
nonpointer: 表示是否对 isa 指针开启指针优化
• 0: 纯 isa 指针
• 1: 不止是类对象地址, isa 中包含了类信息、对象的引用计数等
SideTables:散列表，在散列表中主要有两个表，分别是引用计数表、弱引用表。通过 SideTables()结构来实现的，SideTables()结构下，有很多 SideTable 的数据结构。而 sideTable 当中包含了自旋锁，引用计数表，弱引用表。 SideTables()实际上是一个哈希表，通过对象的地址来计算该对象的引用计数在哪个 sideTable 中。

修饰符

当ARC有效时，id类型和对象类型必须附加所有权修饰符，一共有如下四种。

__strong
__weak
__unsafe_unretained
__autoreleasing

__strong修饰符

__strong修饰符是id类型和对象类型默认的所有权修饰符。

__weak修饰符

弱引用表示并不持有对象，当所引用的对象销毁了，这个变量就自动设为nil。
可以利用__weak修饰符来解决循环引用问题。

__unsafe_unretained修饰符

__unsafe_unretained和__weak很像，唯一区别就是，__unsafe_unretained变量引用的对象再被销毁以后，不会被自动设置为nil，仍然指向对象销毁前的内存地址。所以它的名字叫做unsafe，此时你再尝试通过变量访问这个对象的属性或方法就会crash。一旦对象释放，则会成为悬垂指针，程序崩溃，因此__unnsafe_unretained修饰符的变量一定要在赋值的对象存在的情况下使用。

__autoreleasing修饰符

ARC无效时使用autorelease，在ARC下__autoreleasing的使用：

@autoreleasepool {id __autoreleasing obj = [[NSObject alloc] init];
}