code blocks with Grand Central Dispatch

Question

I'm writing an app using ARC, and I'm wondering if the following will cause a problem. Specifically, I'm creating an object 'A', then using GCD I add a code block to the main thread's queue and in the code block I perform some operations on the weak reference to the object. But by the time the code block is executed, my object has already been nullified. Since the code block only has a weak reference to the object, will this cause a problem? Or does the compiler somehow know to keep a reference to the object since my code block needs it when it runs?

    Foo *A = [[Foo alloc] init];

    __weak Foo *weakA = A;

    dispatch_async(dispatch_get_main_queue(), ^{ 

           //...do something here with weakA
    });

    A = nil;

Thanks!

I'd say... Build and run! Try it out instead of waiting for the answer here. Create a new project and only do that part. — Novarg, Mar 06 '12 at 23:14

score 3 · Answer 1 · edited May 23 '17 at 12:12

Why are you using __weak here? If you want the block to "keep a reference to the object since [your] code block needs it when it runs", then you don't need to do anything:

Foo *a = [[Foo alloc] init];

dispatch_async(dispatch_get_main_queue(), ^{ 
    [a something];      
});

In the above snippet, the block retains a, so it will exist when the block executes.

As this question explains, the only time you need to use __weak with blocks is to break retain cycles that occur when the block itself is going to be retained. For example:

__weak Foo *someObject = [bar getAFoo];

[someObject doSomeTaskWithCompletionHandler:^{
    [someObject doSomethingElse];
}];

Here, if someObject were not declared to be __weak, then you would have a retain cycle since someObject would presumably retain the block (since it would need to keep the block until it was done doing some task), and the block retains someObject. Using __weak here tells the block not to retain someObject, so the error doesn't occur. And you don't need to worry about someObject being nil when the block executes, because someObject owns the block. (If someObject were to be deallocated, then the block wouldn't be executed).

score 2 · Accepted Answer · answered Mar 07 '12 at 00:14

This is an interesting question with some subtleties.

You've explicitly told the compiler to disregard the reference from within the block by tagging it as __weak, so this code is not sufficient to keep the object alive until the block has been executed. It sounds like you're clear on that already, though.

Normally, a weak reference such as weakA would be nullified when the object it refers to is deallocated. However, weakA is a stack variable, so when it's referred to in a block, the block receives a const-ified version of it that memorializes its value at the time of the block's creation. Presumably, this const copy of weakA can't be nullified. See this section of the Apple docs for more on this.

If you change the declaration of weakA to

__block __weak Foo *weakA = A;

then weakA is promoted off the stack and is writable both from its original context and from the block. It still won't keep the referred-to object alive on its own, but at the point of the block's execution you can check to see if its value is nil.

More details on __block can be found here - skip down to the section "ARC Introduces New Lifetime Qualifiers".

code blocks with Grand Central Dispatch

2 Answers2

Linked