#pragma mark - ASDeallocQueue

@implementation ASDeallocQueue {

std::vector<CFTypeRef> _queue;

AS::Mutex _lock;

}

+ (ASDeallocQueue *)sharedDeallocationQueue NS_RETURNS_RETAINED

{

static ASDeallocQueue *deallocQueue = nil;

static dispatch_once_t onceToken;

dispatch_once(&onceToken, ^{

deallocQueue = [[ASDeallocQueue alloc] init];

});

return deallocQueue;

}

- (void)dealloc

{

ASDisplayNodeFailAssert(@"Singleton should not dealloc.");

}

- (void)releaseObjectInBackground:(id _Nullable __strong *)objectPtr

{

NSParameterAssert(objectPtr != NULL);

// Cast to CFType so we can manipulate retain count manually.

const auto cfPtr = (CFTypeRef *)(void *)objectPtr;

if (!cfPtr || !*cfPtr) {

return;

}

_lock.lock();

const auto isFirstEntry = _queue.empty();

// Push the pointer into our queue and clear their pointer.

// This "steals" the +1 from ARC and nils their pointer so they can't

// access or release the object.

_queue.push_back(*cfPtr);

*cfPtr = NULL;

_lock.unlock();

if (isFirstEntry) {

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.100 * NSEC_PER_SEC)), dispatch_get_global_queue(QOS_CLASS_DEFAULT, 0), ^{

[self drain];

});

}

}

- (void)drain

{

_lock.lock();

const auto q = std::move(_queue);

_lock.unlock();

for (CFTypeRef ref : q) {

// NOTE: Could check that retain count is 1 and retry later if not.

CFRelease(ref);

}

}

ASDK_EXTERN void ASPerformBackgroundDeallocation(id __strong _Nullable * _Nonnull object);

void ASPerformBackgroundDeallocation(id __strong _Nullable * _Nonnull object)

{

[[ASDeallocQueue sharedDeallocationQueue] releaseObjectInBackground:object];

}

// Now that the autorelease pool is drained, drain the dealloc queue also.

[[ASDeallocQueue sharedDeallocationQueue] drain];

// Data controller & range controller may own a ton of nodes, let's deallocate those off-main.

ASPerformBackgroundDeallocation(&_dataController);

ASPerformBackgroundDeallocation(&_rangeController);

For the latter case in which the container node is no longer used and thus released, their cell nodes are not released immediately. That is because collection and table nodes might hold a large number of cell nodes and releasing all of them (and their subnodes, more on this later) at the same time can cause a noticeable delay. To avoid that, ASCollectionNode and ASTableNode release their instance variables, most noticeably an ASDataController instance, on a background thread using a helper called ASDeallocQueue. Since the ASDataController instance is the true owner of all cell nodes -- it has a strong reference to all of them --, all of those cell nodes are deallocated off the main thread as well. As a result, you can expect a delay from which a collection or table view is released until all the cell nodes are fully released and their memory reclaimed. It's important to remember this when debugging memory leaks: objects referenced by the data controller may take a bit to show as dealloced by Instruments.

As mentioned above, ASDeallocQueue helps to defer the deallocation of objects given to it by increasing the reference count of each object -- essentially retaining them and acting as their sole owner -- and then release them later on a background thread.

An alternative method is to manage the duration of the lock hold manually rather than using the runtime and scope. You must remember to unlock.

__Method 3__

`ASPerformBackgroundDeallocation(&object)` | Schedule async deallocation of __non-UIKit__ objects