Using __block and __weak

by

__block is a storage qualifier. It specifies that the variable should directly be captured by the block as opposed to copying it. This is useful in case you need to modify the original variable, as in the following example

__block NSString *aString = @"Hey!"; 
void(^aBlock)() = ^{ aString = @"Hello!" }; // without __block you couldn't modify aString
NSLog(@"%@", aString); // Hey!
aBlock();
NSLog(@"%@", aString); // Hello!

In ARC this causes the variable to be automatically retained, so that it can be safely referenced within the block implementation. In the previous example, then, aString is sent a retain message when captured in the block context.

Note that this isn’t true in MRC (Manual Reference Counting), where the variable is referenced without being retained.

Marking it as __weak causes the variable not to be retained, so the block directly refers to it but without retaining it. This is potentially dangerous since in case the block lives longer than the variable, since it will be referring to garbage memory (and likely to crash).

Here’s the relevant paragraph from the clang doc:

In the Objective-C and Objective-C++ languages, we allow the __weak specifier for __block variables of object type. […] This qualifier causes these variables to be kept without retain messages being sent. This knowingly leads to dangling pointers if the Block (or a copy) outlives the lifetime of this object.

Finally the claim that __block can be used to avoid strong reference cycles (aka retain cycles) is plain wrong in an ARC context. Due to the fact that in ARC __block causes the variable to be strongly referenced, it’s actually more likely to cause them.

For instance in MRC this code breaks a retain cycle

__block typeof(self) blockSelf = self; //this would retain self in ARC!
[self methodThatTakesABlock:^ {
    [blockSelf doSomething];
}];

whereas to achieve the same result in ARC, you normally do

__weak typeof(self) weakSelf = self;
[self methodThatTakesABlock:^ {
    [weakSelf doSomething];
}];

More Related Contents:

  1. What is the difference between a __weak and a __block reference?
  2. How do I avoid capturing self in blocks when implementing an API?
  3. What does the “__block” keyword mean?
  4. Retain cycle on `self` with blocks
  5. Custom completion block for my own method [duplicate]
  6. Why isn’t my weak reference cleared right after the strong ones are gone?
  7. When to use enumerateObjectsUsingBlock vs. for
  8. Assign a variable inside a Block to a variable outside a Block
  9. Implementing a method taking a block to use as callback
  10. Weak NSString variable is not nil after setting the only strong reference to nil
  11. What does this caret ^ syntax, with void on either side mean? [duplicate]
  12. Caret character between types rather than variables, surrounded by parentheses
  13. Block Declaration Syntax List
  14. Why can’t we use a dispatch_sync on the current queue?
  15. Alternatives to dispatch_get_current_queue() for completion blocks in iOS 6?
  16. How to dispatch on main queue synchronously without a deadlock?
  17. How to simplify callback logic with a Block?
  18. Checking Objective-C block type?
  19. How does a Block capture the variables outside of its enclosing scope?
  20. Why do nil / NULL blocks cause bus errors when run?
  21. What is the difference between class and instance methods?
  22. What are the details of “Objective-C Literals” mentioned in the Xcode 4.4 release notes?
  23. How to control the line spacing in UILabel
  24. iOS 8 Snapshotting a view that has not been rendered results in an empty snapshot
  25. CoreData relationship fault?
  26. What is the difference between ivars and properties in Objective-C
  27. With what should I replace the deprecated sizeWithFont: method?
  28. Ask permission to access Camera Roll
  29. How to wake from sleep programmatically if lid closed?
  30. Objective C: How to create a multi-line UITextField? [duplicate]

Leave a Comment