Referencing an NSOperation object in its own completion block with ARC

Question

I'm having difficulty converting some NSOperation code to ARC. My operation object uses a completion block, which in turn contains a GCD block that updates the UI on the main thread. Because I reference my operation object from inside its own completion block, I'm using a __weak pointer to avoid a memory leak. However, the pointer is already set to nil by the time my code runs.

I've narrowed it down to this code sample. Anyone know where I went wrong, and the right way to accomplish this?

NSOperationSubclass *operation = [[NSOperationSubclass alloc] init];
__weak NSOperationSubclass *weakOperation = operation;

[operation setCompletionBlock:^{
    dispatch_async( dispatch_get_main_queue(), ^{

        // fails the check
        NSAssert( weakOperation != nil, @"pointer is nil" );

        ...
    });
}];

Well, what went wrong is that a weak pointer doesn't hold ownership. If there's nothing else holding the variable (and there isn't), it's going to get purged. Are you sure you get a leak if you use `operation`? It seems like it should disappear when the completion block is released, which it should be as soon as it's called. (That might be naive, though.) — Steven Fisher, Feb 10 '12 at 05:59
ARC was complaining about it at at compile time. Without it I was using the operation pointer directly (and I don't believe I was leaking memory). — Marc Charbonneau, Feb 10 '12 at 06:29
Good luck with this. I think I struggled against it for several hours before giving up and doing something else. But it's been a while. :) — Steven Fisher, Feb 10 '12 at 16:30

score 16 · Answer 1 · answered Feb 13 '13 at 14:27

Another option would be:

NSOperationSubclass *operation = [[NSOperationSubclass alloc] init];
__weak NSOperationSubclass *weakOperation = operation;

[operation setCompletionBlock:^{
    NSOperationSubclass *strongOperation = weakOperation;

    dispatch_async(dispatch_get_main_queue(), ^{
        assert(strongOperation != nil);
        ...
    });
}];

[operationQueue addOperation:operation];

I assume you also add operation object to an NSOperationQueue. In that case, the queue is retaining an operation. It is probably also retaining it during execution of the completion block (although I haven't found official confirmation about the completion block).

But inside you completion block another block is created. That block will be run at some point in time later, possibly after NSOperations's completion block is run to an end. When this happens, operation will be released by the queue and weakOperation will be nil. But if we create another strong reference to the same object from operation's completion block, we'll make sure operation will exist when the second block is run, and avoid retain cycle because we don't capture operation variable by the block.

Apple provides this example in Transitioning to ARC Release Notes see the last code snippet in Use Lifetime Qualifiers to Avoid Strong Reference Cycles section.

+1 This is the correct answer. The `NSOperation` retains the completion block, so it is safe to use a weak reference to it in the completion block, because it's guaranteed to be still alive. However, the OP's problem is that they are using it in the second block, which is executed later, and the weak reference is not guaranteed to be alive there. The correct solution is to have the second block have a strong reference to the `NSOperation` — user102008, Apr 02 '13 at 01:38

score 10 · Accepted Answer · edited May 23 '17 at 12:01

I'm not certain about this, but the correct way to do it is possibly to add __block to the variable in question, and then set it to nil at the end of the block to ensure that it is released. See this question.

Your new code would look like this:

NSOperationSubclass *operation = [[NSOperationSubclass alloc] init];
__block NSOperationSubclass *weakOperation = operation;

[operation setCompletionBlock:^{
    dispatch_async( dispatch_get_main_queue(), ^{

        // fails the check
        NSAssert( weakOperation != nil, @"pointer is nil" );

        ...
        weakOperation = nil;
    });

}];

score 5 · Answer 3 · answered Nov 13 '14 at 11:50

Accepted answer is correct. However there is no need to weakify operation as of iOS 8 / Mac OS 10.10:

the quote from NSOperation documentation on @completionBlock:

In iOS 8 and later and OS X v10.10 and later, this property is set to nil after the completion block begins executing.

See also this tweet from Pete Steinberger.

Referencing an NSOperation object in its own completion block with ARC

3 Answers3

Linked