前言
AutoreleasePoolPage 结构
AutoreleasePoolPage 是一个C++实现的类, 实现双向链表。
class AutoreleasePoolPage
{
#if PROTECT_AUTORELEASEPOOL
PAGE_MAX_SIZE; // must be multiple of vm page size
#else
//#define I386_PGBYTES 4096 /* bytes per 80386 page */
//#define PAGE_MAX_SIZE PAGE_SIZE
PAGE_MAX_SIZE; // size and alignment, power of 2
#endif
static size_t const COUNT = SIZE / sizeof(id);
//magic用来校验AutoreleasePoolPage结构是否完整
magic_t const magic;
//next指向第一个可用的地址
id *next;
//thread指向当前的线程；
pthread_t const thread;
//parent指向父类
AutoreleasePoolPage * const parent;
//child指向子类
AutoreleasePoolPage *child;
uint32_t const depth;
uint32_t hiwat;
......
}
AutoreleasePoolPage每个对象会开辟4096字节内存（也就是虚拟内存一页的大小），除了上面的实例变量所占空间，剩下的空间全部用来储存autorelease对象的地址
autoreleasepool的创建
void *objc_autoreleasePoolPush(void)
{
if (UseGC) return nil;
return AutoreleasePoolPage::push();
}
static inline void *push()
{
id *dest;
if (DebugPoolAllocation) {
// Each autorelease pool starts on a new pool page.
dest = autoreleaseNewPage(POOL_BOUNDARY);
} else {
dest = autoreleaseFast(POOL_BOUNDARY);
}
return dest;
}
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);
}
}
这个方法就是AutoreleasePoolPage具体初始化的地方，看实现知道有三种情况.
hotPage存在并且容量没有满，直接添加对象hotPage存在但是容量已经满了，调用autoreleaseFullPage方法，初始化一个AutoreleasePoolPage并把page传入，并标记为hotPage；hotPage不存在，调用autoreleaseNoPage创建一个AutoreleasePoolPage，并标记为hotePage，并且添加一个POOL_SENTINEL（哨兵对象）
关键inline，其实就是内联函数，可以提供执行速度
对象如何加入到autoreleasepool 中的
- 当对象调用
【object autorelease】的方法的时候就会加到autoreleasepool中。
+(id) autorelease {
return self;
}
// Replaced by ObjectAlloc
- (id)autorelease {
return ((id)self)->rootAutorelease();
}
inline id
objc_object::rootAutorelease()
{
if (isTaggedPointer()) return (id)this;
if (prepareOptimizedReturn(ReturnAtPlus1)) return (id)this;
return rootAutorelease2();
}
__attribute__((noinline,used))
id
objc_object::rootAutorelease2()
{
assert(!isTaggedPointer());
return AutoreleasePoolPage::autorelease((id)this);
}
public:
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;
}
-
autoreleaseFast(obj);上面有。 autoreleasepool push时的主要方法。 - 只有
push操作会产生POOL_SENTINEL 哨兵； -
POOL_SENTINEL的个数就是autoreleasepool的个数，实际开发中会有嵌套使用的情况
autoreleasepool 中的Pop
static inline void pop(void *token) // token指针指向栈顶的地址
{
AutoreleasePoolPage *page = pageForPointer(token); // 通过栈顶的地址找到对应的page
id *stop = (id *)token;
if (PrintPoolHiwat) printHiwat(); // 记录最高水位标记
page->releaseUntil(stop); // 从栈顶开始操作出栈，并向栈中的对象发送release消息，直到遇到第一个哨兵对象
// 删除空掉的节点
if (page->child) {
if (page->lessThanHalfFull()) {
page->child->kill();
} else if (page->child->child) {
page->child->child->kill();
}
}
}
该静态方法总共做了三件事情：
使用pageForPointer获取当前 token（哨兵对象）， 所在的AutoreleasePoolPage
调用releaseUntil方法释放栈中的对象，直到stop，
调用child的kill方法
AutoreleasePool创建和释放
- App启动后，苹果在主线程 RunLoop 里注册了两个 Observer，其回调都是 _wrapRunLoopWithAutoreleasePoolHandler()。
- 第一个 Observer 监视的事件是 Entry(即将进入Loop)，其回调内会调用 _objc_autoreleasePoolPush() 创建自动释放池。其 order 是-2147483647，优先级最高，保证创建释放池发生在其他所有回调之前。
- 第二个 Observer 监视了两个事件： BeforeWaiting(准备进入休眠) 时调用_objc_autoreleasePoolPop() 和 _objc_autoreleasePoolPush() 释放旧的池并创建新池；Exit(即将退出Loop) 时调用 _objc_autoreleasePoolPop() 来释放自动释放池。这个 Observer 的 order 是 2147483647，优先级最低，保证其释放池子发生在其他所有回调之后。
- 在主线程执行的代码，通常是写在诸如事件回调、Timer回调内的。这些回调会被 RunLoop 创建好的 AutoreleasePool 环绕着，所以不会出现内存泄漏，开发者也不必显示创建 Pool 了。
也就是说AutoreleasePool创建是在一个RunLoop事件开始之前(push)，AutoreleasePool释放是在一个RunLoop事件即将结束之前(pop)。
AutoreleasePool里的Autorelease对象的加入是在RunLoop事件中，AutoreleasePool里的Autorelease对象的释放是在AutoreleasePool释放时。
/***********************************************************************
* call_load_methods
* Call all pending class and category +load methods.
* Class +load methods are called superclass-first.
* Category +load methods are not called until after the parent class's +load.
*
* This method must be RE-ENTRANT, because a +load could trigger
* more image mapping. In addition, the superclass-first ordering
* must be preserved in the face of re-entrant calls. Therefore,
* only the OUTERMOST call of this function will do anything, and
* that call will handle all loadable classes, even those generated
* while it was running.
*
* The sequence below preserves +load ordering in the face of
* image loading during a +load, and make sure that no
* +load method is forgotten because it was added during
* a +load call.
* Sequence:
* 1. Repeatedly call class +loads until there aren't any more
* 2. Call category +loads ONCE.
* 3. Run more +loads if:
* (a) there are more classes to load, OR
* (b) there are some potential category +loads that have
* still never been attempted.
* Category +loads are only run once to ensure "parent class first"
* ordering, even if a category +load triggers a new loadable class
* and a new loadable category attached to that class.
*
* Locking: loadMethodLock must be held by the caller
* All other locks must not be held.
**********************************************************************/
void call_load_methods(void)
{
static bool loading = NO;
bool more_categories;
loadMethodLock.assertLocked();
// Re-entrant calls do nothing; the outermost call will finish the job.
if (loading) return;
loading = YES;
void *pool = objc_autoreleasePoolPush();
do {
// 1. Repeatedly call class +loads until there aren't any more
while (loadable_classes_used > 0) {
call_class_loads();
}
// 2. Call category +loads ONCE
more_categories = call_category_loads();
// 3. Run more +loads if there are classes OR more untried categories
} while (loadable_classes_used > 0 || more_categories);
objc_autoreleasePoolPop(pool);
loading = NO;
}
AutoreleasePool对象什么时候释放？
在没有手加
Autorelease Pool的情况下，Autorelease对象是在当前的runloop迭代结束时释放的，而它能够释放的原因是系统在每个runloop迭代中都加入了自动释放池Push和Pop.
子线程Autorelease
在子线程你创建了 Pool 的话，产生的 Autorelease 对象就会交给 pool 去管理。如果你没有创建 Pool ，但是产生了 Autorelease 对象，就会调用 autoreleaseNoPage 方法。在这个方法中，会自动帮你创建一个 hotpage（hotPage 可以理解为当前正在使用的 AutoreleasePoolPage，如果你还是不理解，可以先看看 Autoreleasepool 的源代码，再来看这个问题 ）
什么对象自动加入到 autoreleasepool中
虽然在程序入口，已经帮我们加上了 autoreleasepool，但是并不是说大括号内的所有
对象都会交给autoreleasepool来处理
第一种：
当使用alloc/new/copy/mutableCopy开始的方法进行初始化时，会生成并持有对象(也就是不需要pool管理，系统会自动的帮他在合适位置release)
例如： NSObject *stu = [[NSObject alloc] init];
那么对于其他情况，例如
id obj = [NSMutableArray array];
这种情况会自动将返回值的对象注册到autorealeasepool，代码等效于：
@autorealsepool{
id __autorealeasing obj = [NSMutableArray array];
}
编译器会通过objc_autoreleaseReturnValue和objc_retainAutoreleasedReturnValue和个两个函数不将对象注册到autoreleasepool里而直接传递，所以说这种情况并没有把对象添加到autoreleasepool？ [NSMutableArray array];返回的对象后,如果外部是强引用, 则编译器优化了, 并不会添加进入pool中!
第二种
__weak修饰符只持有对象的弱引用，而在访问引用对象的过程中，该对象可能被废弃。那么如果把对象注册到autorealeasepool中，那么在@autorealeasepool块结束之前都能确保对象的存在。
最新的情况是weak修饰的对象不会再被加入到Pool中了，具体可参考：https://stackoverflow.com/questions/40993809/why-weak-object-will-be-added-to-autorelease-pool
id __weak obj1 = obj0;
NSLog(@"class=%@",[obj1 class]);
对应的模拟源码为
id __weak obj1 = obj0;
id __autorealeasing tmp = obj1;
NSLog(@"class=%@",[tmp class]);
第三种
id的指针或对象的指针在没有显式指定时会被附加上__autorealeasing修饰符.
+ (nullable instancetype)stringWithContentsOfURL:(NSURL *)url
encoding:(NSStringEncoding)enc
error:(NSError **)error;
等价于
NSString *str = [NSString stringWithContentsOfURL:
encoding:
error:<#(NSError * _Nullable __autoreleasing * _Nullable)#>]
参考：
自动释放池的前世今生 ---- 深入解析 autoreleasepool-InfoQ
oc篇-深入理解@autoreleasepool
你不知道的TaggedPointer
AutoreleasePool 的总结
深入理解 AutoreleasePool（iOS）
自动释放池的前世今生 ---- 深入解析 Autoreleasepool
引用计数带来的一次讨论
does NSThread create autoreleasepool automatically now?does NSThread create autoreleasepool automaticly now?