CODEWITHSUNDEEP
objective-cobjective-c-blocksgrand-central-dispatch
InternationalCodingGuru
InternationalCodingGuru

Reputation: 2258

code blocks with Grand Central Dispatch

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!

Upvotes: 1

Views: 768

Answers (2)

GSnyder
GSnyder

Reputation: 480

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".

Upvotes: 2

yuji
yuji

Reputation: 16725

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).

Upvotes: 3

Related Questions