### self的循环引用
当使用代码块和异步分发的时候，要注意避免引用循环。总是使用`weak`来引用对象，避免引用循环。（译者注：这里更为优雅的方式是采用影子变量@weakify/@strongify[这里有更为详细的说明](https://github.com/jspahrsummers/libextobjc/blob/master/extobjc/EXTScope.h)）此外，把持有block的属性设置为nil (比如`self.completionBlock = nil`)是一个好的实践。它会打破block捕获的作用域带来的引用循环。
**例子:**
```objective-c
__weak __typeof(self) weakSelf =self;
[selfexecuteBlock:^(NSData *data, NSError *error) {
[weakSelf doSomethingWithData:data];
}];
```
**不要这样:**
```objective-c
[selfexecuteBlock:^(NSData *data, NSError *error) {
[selfdoSomethingWithData:data];
}];
```
**多个语句的例子:**
```objective-c
__weak __typeof(self)weakSelf =self;
[selfexecuteBlock:^(NSData *data, NSError *error) {
__strong __typeof(weakSelf) strongSelf = weakSelf;
if(strongSelf) {
[strongSelf doSomethingWithData:data];
[strongSelf doSomethingWithData:data];
}
}];
```
**不要这样:**
```objective-c
__weak __typeof(self)weakSelf =self;
[selfexecuteBlock:^(NSData *data, NSError *error) {
[weakSelf doSomethingWithData:data];
[weakSelf doSomethingWithData:data];
}];
```
你应该把这两行代码作为 snippet 加到 Xcode 里面并且总是这样使用它们。
```objective-c
__weak __typeof(self)weakSelf =self;
__strong __typeof(weakSelf)strongSelf = weakSelf;
```
这里我们来讨论下block里面的self的`__weak`和`__strong` 限定词的一些微妙的地方。简而言之，我们可以参考self在block里面的三种不同情况。
1.直接在block里面使用关键词self
2.在block外定义一个`__weak`的引用到self，并且在block里面使用这个弱引用
3.在block外定义一个`__weak`的引用到self，并在在block内部通过这个弱引用定义一个`__strong` 的引用。
**方案 1. 直接在 block 里面使用关键词 `self`**
如果我们直接在 block 里面用 self 关键字，对象会在 block 的定义时候被 retain，（实际上 block 是[copied][blocks_caveat13] 但是为了简单我们可以忽略这个）。一个 const 的对 self 的引用在 block 里面有自己的位置并且它会影响对象的引用计数。如果这个block被其他的类使用并且(或者)彼此间传来传去，我们可能想要在 block 中保留 self，就像其他在 block 中使用的对象一样. 因为他们是block执行所需要的.
```objective-c
dispatch_block_t completionBlock = ^{
NSLog(@"%@",self);
}
MyViewController *myController = [[MyViewController alloc] init...];
[selfpresentViewController:myController
animated:YES
completion:completionHandler];
```
没啥大不了。但是如果通过一个属性中的 `self` 保留 了这个 block（就像下面的例程一样）,对象( self )保留了 block 会怎么样呢？
```objective-c
self.completionHandler = ^{
NSLog(@"%@",self);
}
MyViewController *myController = [[MyViewController alloc] init...];
[selfpresentViewController:myController
animated:YES
completion:self.completionHandler];
```
这就是有名的 retain cycle, 并且我们通常应该避免它。这种情况下我们收到 CLANG 的警告：
```objective-c
Capturing 'self' strongly inthisblock is likely to lead to a retain cycle（在block里面发现了`self`的强引用，可能会导致循环引用）
```
所以`__weak`就有用武之地了。
**方案 2. 在 block 外定义一个 `__weak` 的 引用到 self，并且在 block 里面使用这个弱引用**
这样会避免循坏引用，也是通常情况下我们的block作为类的属性被self retain 的时候会做的。
```objective-c
__weak typeof(self) weakSelf =self;
self.completionHandler = ^{
NSLog(@"%@", weakSelf);
};
MyViewController *myController = [[MyViewController alloc] init...];
[selfpresentViewController:myController
animated:YES
completion:self.completionHandler];
```
这个情况下 block 没有 retain 对象并且对象在属性里面 retain 了 block 。所以这样我们能保证了安全的访问 self。 不过糟糕的是，它可能被设置成 nil 的。问题是：如何让 self 在 block 里面安全地被销毁。
考虑这么个情况：block 作为属性(property)赋值的结果，从一个对象被复制到另一个对象(如 myController)，在这个复制的 block 执行之前，前者（即之前的那个对象）已经被解除分配。
下面的更有意思。
**方案 3. 在 block 外定义一个 `__weak` 的 引用到 self，并在在 block 内部通过这个弱引用定义一个`__strong` 的引用**
你可能会想，首先，这是避免retain cycle 警告的一个技巧。
这不是重点，这个self的强引用是在block执行时被创建的，但是否使用self在block定义时就已经定下来了，因此self (在block执行时)会被retain.
[Apple文档][blocks_caveat1]中表示"为了non-trivial cycles，你应该这样"：
```objective-c
MyViewController *myController = [[MyViewController alloc] init...];
// ...
MyViewController* __weak weakMyController = myController;
myController.completionHandler= ^(NSInteger result) {
MyViewController *strongMyController = weakMyController;
if(strongMyController) {
// ...
[strongMyController dismissViewControllerAnimated:YES completion:nil];
// ...
}
else{
// Probably nothing...
}
};
```
首先，我觉得这个例子看起来是错误的。如果block本身在completionHandler属性中被retain了，那么self如何被delloc和在block之外赋值为nil呢? completionHandler属性可以被声明为 `assign`或者`unsafe_unretained`的，来允许对象在block被传递之后被销毁。
我不能理解这样做的理由，如果其他对象需要这个对象（self），block 被传递的时候应该 retain 对象，所以 block 应该不被作为属性存储。这种情况下不应该用 `__weak`/`__strong`
总之，其他情况下，希望 weakSelf 变成 nil 的话，就像第二种情况解释那么写（在 block 之外定义一个弱应用并且在 block 里面使用）。
还有，Apple的 "trivial block" 是什么呢。我们的理解是 trivial block 是一个不被传送的 block ，它在一个良好定义和控制的作用域里面，weak 修饰只是为了避免循环引用。
虽然有 Kazuki Sakamoto 和 Tomohiko Furumoto) 讨论的[一][blocks_caveat2][些][blocks_caveat3][的][blocks_caveat4][在线][blocks_caveat5][参考][blocks_caveat6], [Matt Galloway][blocks_caveat16]的([Effective Objective-C 2.0][blocks_caveat14]和[Pro Multithreading and Memory Management for iOS and OS X][blocks_caveat15]，大多数开发者始终没有弄清楚概念。
在 block 内用强引用的优点是，抢占执行的时候的鲁棒性。在 block 执行的时候, 再次温故下上面的三个例子：
**方案 1. 直接在 block 里面使用关键词 `self`**
如果block被属性retain，self和block之间会有一个循环引用并且它们不会再被释放。如果block被传送并且被其他的对象copy了，self在每一个copy里面被retain
**方案 2. 在 block 外定义一个 `__weak` 的 引用到 self，并且在 block 里面使用这个弱引用**
不管 block 是否通过属性被 retain ，这里都不会发生循环引用。如果 block 被传递或者 copy 了，在执行的时候，weakSelf 可能已经变成 nil。
block 的执行可以抢占，而且对 weakSelf 指针的调用时序不同可以导致不同的结果(如：在一个特定的时序下 weakSelf 可能会变成nil)。
```objective-c
__weak typeof(self) weakSelf =self;
dispatch_block_t block = ^{
[weakSelf doSomething];// weakSelf != nil
// preemption, weakSelf turned nil
[weakSelf doSomethingElse];// weakSelf == nil
};
```
**方案 3. 在 block 外定义一个 `__weak` 的 引用到 self，并在在 block 内部通过这个弱引用定义一个`__strong` 的引用。**
不管 block 是否通过属性被 retain ，这里也不会发生循环引用。如果 block 被传递到其他对象并且被复制了，执行的时候，weakSelf 可能被nil，因为强引用被赋值并且不会变成nil的时候，我们确保对象 在 block 调用的完整周期里面被 retain了，如果抢占发生了，随后的对 strongSelf 的执行会继续并且会产生一样的值。如果 strongSelf 的执行到 nil，那么在 block 不能正确执行前已经返回了。
```objective-c
__weak typeof(self) weakSelf =self;
myObj.myBlock= ^{
__strong typeof(self) strongSelf = weakSelf;
if(strongSelf) {
[strongSelf doSomething];// strongSelf != nil
// preemption, strongSelf still not nil（抢占的时候，strongSelf还是非nil的)
[strongSelf doSomethingElse];// strongSelf != nil
}
else{
// Probably nothing...
return;
}
};
```
在ARC条件中，如果尝试用 `->` 符号访问一个实例变量，编译器会给出非常清晰的错误信息：
```objective-c
Dereferencing a __weak pointer is not allowed due to possiblenullvalue caused by race condition, assign it to a strong variable first. (对一个__weak指针的解引用不允许的，因为可能在竞态条件里面变成null,所以先把他定义成strong的属性)
```
可以用下面的代码展示
```objective-c
__weak typeof(self) weakSelf =self;
myObj.myBlock= ^{
id localVal = weakSelf->someIVar;
};
```
在最后
***方案 1**:只能在block不是作为一个property的时候使用，否则会导致retain cycle。
***方案 2**: 当block被声明为一个property的时候使用。
* **方案 3**: 和并发执行有关。当涉及异步的服务的时候，block 可以在之后被执行，并且不会发生关于 self 是否存在的问题。
[blocks_caveat1]: https://developer.apple.com/library/mac/#releasenotes/ObjectiveC/RN-TransitioningToARC/Introduction/Introduction.html
[blocks_caveat2]: https://dhoerl.wordpress.com/2013/04/23/i-finally-figured-out-weakself-and-strongself/
[blocks_caveat3]: http://blog.random-ideas.net/?p=160
[blocks_caveat4]: http://stackoverflow.com/questions/7904568/disappearing-reference-to-self-in-a-block-under-arc
[blocks_caveat5]: http://stackoverflow.com/questions/12218767/objective-c-blocks-and-memory-management
[blocks_caveat6]: https://github.com/AFNetworking/AFNetworking/issues/807
[blocks_caveat10]: https://twitter.com/pedrogomes
[blocks_caveat11]: https://twitter.com/dmakarenko
[blocks_caveat12]: https://ef.com
[blocks_caveat13]: https://developer.apple.com/library/ios/documentation/cocoa/conceptual/Blocks/Articles/bxVariables.html#//apple_ref/doc/uid/TP40007502-CH6-SW4
[blocks_caveat14]: http://www.effectiveobjectivec.com/
[blocks_caveat15]: http://www.amazon.it/Pro-Multithreading-Memory-Management-Ios/dp/1430241160
[blocks_caveat16]: https://twitter.com/mattjgalloway