带着问题看源码----子线程AutoRelease对象何时释放

发表于

首先是一个常规问题，autorelease对象何时释放？答：在AutoreleasePoolPage pop的时候释放，在主线程的runloop中，有两个oberserver负责创建和清空autoreleasepool，详情可以看YY的深入理解runloop。那么子线程呢？子线程的runloop都需要手动开启，那么子线程中使用autorelease对象会内存泄漏吗，如果不会又是什么时候释放呢。

Runloop源码

带着这个问题，我们看一看runloop的源码中给出的答案。

autoreleasepool创建

在MRC下，使用__autoreleasing修饰符等同于MRC下调用autorelease方法，所以在NSObject源码中找到-(id)autorelese方法开始看。

1
2
3
4
-(id) autorelease
{
    return _objc_rootAutorelease(self);
}

可以看到这个方法里只是简单的调了一下_objc_rootAutorelease()，继续跟进。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
id
_objc_rootAutorelease(id obj)
{
    assert(obj);
    return obj->rootAutorelease();
}

...

// Base autorelease implementation, ignoring overrides.
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);
}

检查是否AutoreleasePoolPage::autorelease是标签指针和是否要做不加入autoreleasepool的优化，然后rootAutorelease2()。最后走入了AutoreleasePoolPage::autorelease()。
接下来看看AutoreleasePoolPage这个类，有关这个类的说明，可以看看sunny的黑幕背后的Autorelease。现在来看看AutoreleasePoolPage中的实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
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;
    }
    ...
    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);
        }
    }
    ...
        static __attribute__((noinline))
    id *autoreleaseNoPage(id obj)
    {
        // "No page" could mean no pool has been pushed
        // or an empty placeholder pool has been pushed and has no contents yet
        assert(!hotPage());

        bool pushExtraBoundary = false;
        if (haveEmptyPoolPlaceholder()) {
            // We are pushing a second pool over the empty placeholder pool
            // or pushing the first object into the empty placeholder pool.
            // Before doing that, push a pool boundary on behalf of the pool 
            // that is currently represented by the empty placeholder.
            pushExtraBoundary = true;
        }
        else if (obj != POOL_BOUNDARY  &&  DebugMissingPools) {
            // We are pushing an object with no pool in place, 
            // and no-pool debugging was requested by environment.
            _objc_inform("MISSING POOLS: (%p) Object %p of class %s "
                         "autoreleased with no pool in place - "
                         "just leaking - break on "
                         "objc_autoreleaseNoPool() to debug", 
                         pthread_self(), (void*)obj, object_getClassName(obj));
            objc_autoreleaseNoPool(obj);
            return nil;
        }
        else if (obj == POOL_BOUNDARY  &&  !DebugPoolAllocation) {
            // We are pushing a pool with no pool in place,
            // and alloc-per-pool debugging was not requested.
            // Install and return the empty pool placeholder.
            return setEmptyPoolPlaceholder();
        }

        // We are pushing an object or a non-placeholder'd pool.

        // Install the first page.
        AutoreleasePoolPage *page = new AutoreleasePoolPage(nil);
        setHotPage(page);
        
        // Push a boundary on behalf of the previously-placeholder'd pool.
        if (pushExtraBoundary) {
            page->add(POOL_BOUNDARY);
        }
        
        // Push the requested object or pool.
        return page->add(obj);
    }

这里我们找到了我们想看的代码，如果当前线程没有AutorelesepoolPage的话，代码执行顺序为autorelease -> autoreleaseFast -> autoreleaseNoPage。
在autoreleaseNoPage方法中，会创建一个hotPage，然后调用page->add(obj)。也就是说即使这个线程没有AutorelesepoolPage，使用了autorelease对象时也会new一个AutoreleasepoolPage出来管理autorelese对象，不用担心内存泄漏。

何时释放

明确了何时创建autoreleasepool以后就自然而然的有下一个问题，这个autoreleasepool何时清空？
对于这个问题，这里使用watchpoint set variable命令来观察。
首先是一个最简单的场景，创建一个子线程。

1
2
3
4
__weak id obj;

...
[NSThread detachNewThreadSelector:@selector(createAndConfigObserverInSecondaryThread) toTarget:self withObject:nil];

使用一个weak指针观察子线程中的autorelease对象，子线程中执行的任务。

1
2
3
4
5
6
7
- (void)createAndConfigObserverInSecondaryThread{
    __autoreleasing id test = [NSObject new];
    NSLog(@"obj = %@", test);
    obj = test;
    [[NSThread currentThread] setName:@"test runloop thread"];
    NSLog(@"thread ending");
}

在obj = test处设置断点使用watchpoint set variable obj命令观察obj，可以看到obj在释放时的方法调用栈是这样的。
threadwithoutrunloop
通过这个调用栈可以看到释放的时机在_pthread_exit。然后执行到AutorelepoolPage的tls_dealloc方法。这个方法如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
static void tls_dealloc(void *p)
{
    if (p == (void*)EMPTY_POOL_PLACEHOLDER) {
        // No objects or pool pages to clean up here.
        return;
    }

    // reinstate TLS value while we work
    setHotPage((AutoreleasePoolPage *)p);

    if (AutoreleasePoolPage *page = coldPage()) {
        if (!page->empty()) pop(page->begin());  // pop all of the pools
        if (DebugMissingPools || DebugPoolAllocation) {
            // pop() killed the pages already
        } else {
            page->kill();  // free all of the pages
        }
    }
    
    // clear TLS value so TLS destruction doesn't loop
    setHotPage(nil);
}

在这找到了if (!page->empty()) pop(page->begin());这句关键代码。再往上看一点，在_pthread_exit时会执行下面这个函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
void
_pthread_tsd_cleanup(pthread_t self)
{
#if !VARIANT_DYLD
	int j;

	// clean up dynamic keys first
	for (j = 0; j < PTHREAD_DESTRUCTOR_ITERATIONS; j++) {
		pthread_key_t k;
		for (k = __pthread_tsd_start; k <= self->max_tsd_key; k++) {
			_pthread_tsd_cleanup_key(self, k);
		}
	}

	self->max_tsd_key = 0;

	// clean up static keys
	for (j = 0; j < PTHREAD_DESTRUCTOR_ITERATIONS; j++) {
		pthread_key_t k;
		for (k = __pthread_tsd_first; k <= __pthread_tsd_max; k++) {
			_pthread_tsd_cleanup_key(self, k);
		}
	}
#endif // !VARIANT_DYLD
}

也就是说thread在退出时会释放自身资源，这个操作就包含了销毁autoreleasepool，在tls_delloc中，执行了pop操作。
这个实验本该到此就结束了，对于文章开始的问题在这里也已经有了答案，线程在销毁时会清空autoreleasepool。但是上述这个例子中的线程并没有加入runloop，只是一个一次性的线程。现在给这个线程加入runloop来看看效果会是怎么样的。

runloop source & autoreleasepool

对于runloop，我们知道runloop一定要有source才能保证run起来以后不立即结束，而source有三种，custom source，port source，timer。
先加一个timer试试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
- (void)createAndConfigObserverInSecondaryThread{
    [[NSThread currentThread] setName:@"test runloop thread"];
    NSRunLoop *loop = [NSRunLoop currentRunLoop];
    CFRunLoopObserverRef observer;
    observer = CFRunLoopObserverCreate(CFAllocatorGetDefault(),
                                       kCFRunLoopAllActivities,
                                       true,      // repeat
                                       0xFFFFFF,  // after CATransaction(2000000)
                                       YYRunLoopObserverCallBack, NULL);
    CFRunLoopRef cfrunloop = [loop getCFRunLoop];
    if (observer) {
        
        CFRunLoopAddObserver(cfrunloop, observer, kCFRunLoopCommonModes);
        CFRelease(observer);
    }
    [NSTimer scheduledTimerWithTimeInterval:5 target:self selector:@selector(testAction) userInfo:nil repeats:YES];
    [loop run];
    NSLog(@"thread ending");
}

- (void)testAction{
    __autoreleasing id test = [NSObject new];
    obj = test;
    NSLog(@"obj = %@", obj);
}

这里的oberserver没有什么，就是从YYKit里复制出来的一段observer代码，用于监控runloop的状态。感兴趣的可以看看。
在testAction()中加上watchpoint断点，观察obj的释放时机。

可以看到释放的时机在CFRunloopRunSpecific中，也就是runloop切换状态的时候，继续往上看发现__CFRUNLOOP_IS_CALLING_OUT_TO_A_TIMER_CALLBACK_FUNCTION__()这个回调。这个函数中的实现如下

1
2
3
4
5
6
static void __CFRUNLOOP_IS_CALLING_OUT_TO_A_TIMER_CALLBACK_FUNCTION__(CFRunLoopTimerCallBack func, CFRunLoopTimerRef timer, void *info) {
    if (func) {
        func(timer, info);
    }
    asm __volatile__(""); // thwart tail-call optimization
}

这个名为func的callback是timer的一个属性，根据这个调用栈看到，释放autoreleasepool的操作应该是在这个callback中。这里猜测一下timer，应该是在自己的callback函数里插入了释放autorelesepool的代码。
然后用自己实现的source试一试，

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
- (void)createAndConfigObserverInSecondaryThread{
    __autoreleasing id test = [NSObject new];
    NSLog(@"obj = %@", test);
    obj = test;
    [[NSThread currentThread] setName:@"test runloop thread"];
    NSRunLoop *loop = [NSRunLoop currentRunLoop];
    CFRunLoopObserverRef observer;
    observer = CFRunLoopObserverCreate(CFAllocatorGetDefault(),
                                       kCFRunLoopAllActivities,
                                       true,      // repeat
                                       0xFFFFFF,  // after CATransaction(2000000)
                                       YYRunLoopObserverCallBack, NULL);
    CFRunLoopRef cfrunloop = [loop getCFRunLoop];
    if (observer) {
        
        CFRunLoopAddObserver(cfrunloop, observer, kCFRunLoopCommonModes);
        CFRelease(observer);
    }
    
    CFRunLoopSourceRef source;
    CFRunLoopSourceContext sourceContext = {0, (__bridge void *)(self), NULL, NULL, NULL, NULL, NULL, NULL, NULL, &runLoopSourcePerformRoutine};
    source = CFRunLoopSourceCreate(NULL, 0, &sourceContext);
    CFRunLoopAddSource(cfrunloop, source, kCFRunLoopDefaultMode);
    runLoopSource = source;
    runLoop = cfrunloop;
    [loop run];
    NSLog(@"thread ending");
}

-(void)wakeupSource{
    //通知InputSource
    CFRunLoopSourceSignal(runLoopSource);
    //唤醒runLoop
    CFRunLoopWakeUp(runLoop);
    
}

...

void runLoopSourcePerformRoutine (void *info)
{
	  __autoreleasing id test = [NSObject new];
    obj = test;
    // 如果不对obj赋值，obj会一直持有createAndConfigObserverInSecondaryThread函数入口的那个object，那个object不受这里面的autoreleasepool影响。
    NSLog(@"obj is %@" , obj);
    NSLog(@"回调方法%@",[NSThread currentThread]);
}

这里wakeupSource()是一个按钮的点击事件，用于唤醒runloop。runloop唤醒之后将执行runLoopSourcePerformRoutine函数，在runLoopSourcePerformRoutine()中观察obj的释放时机，发现是在[NSRunloop run:beforeDate:]中，查看GNU的实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
- (BOOL) runMode: (NSString*)mode beforeDate: (NSDate*)date
{
  NSAutoreleasePool	*arp = [NSAutoreleasePool new];
  NSString              *savedMode = _currentMode;
  GSRunLoopCtxt		*context;
  NSDate		*d;

  NSAssert(mode != nil, NSInvalidArgumentException);

  /* Process any pending notifications.
   */
  GSPrivateNotifyASAP(mode);

  /* And process any performers scheduled in the loop (eg something from
   * another thread.
   */
  _currentMode = mode;
  context = NSMapGet(_contextMap, mode);
  [self _checkPerformers: context];
  _currentMode = savedMode;

  /* Find out how long we can wait before first limit date.
   * If there are no input sources or timers, return immediately.
   */
  d = [self limitDateForMode: mode];
  if (nil == d)
    {
      [arp drain];
      return NO;
    }

  /* Use the earlier of the two dates we have (nil date is like distant past).
   */
  if (nil == date)
    {
      [self acceptInputForMode: mode beforeDate: nil];
    }
  else
    {
      /* Retain the date in case the firing of a timer (or some other event)
       * releases it.
       */
      d = [[d earlierDate: date] copy];
      [self acceptInputForMode: mode beforeDate: d];
      RELEASE(d);
    }

  [arp drain];
  return YES;
}

在GNU的实现中，targer执行相应的action操作是在[self acceptInputForMode: mode beforeDate: d];中，可以看到在runMode: (NSString*)mode beforeDate: (NSDate*)date方法中，其实是包裹了一个autoreleasepool的，也就是arp，如果在深入一些函数里面，发现其实很多地方都有autoreleasepool的函数，所以即使是我们自定义的source，执行函数中没有释放autoreleasepool的操作也不用担心，系统在各个关键入口都给我们加了这些操作。
文章到此就告一段落了，还有一种port source，也就是source1，这种source我没有去看，好奇的同学可以去看一看如果有什么不对我们一起讨论。

总结

1.子线程在使用autorelease对象时，如果没有autoreleasepool会在autoreleaseNoPage中懒加载一个出来。
2.在runloop的run:beforeDate，以及一些source的callback中，有autoreleasepool的push和pop操作，总结就是系统在很多地方都差不多autorelease的管理操作。
3.就算插入没有pop也没关系，在线程exit的时候会释放资源，执行AutoreleasePoolPage::tls_dealloc，在这里面会清空autoreleasepool。

##参考
深入理解runloop
黑幕背后的Autorelease
stackover flow