iOC中block下的__block、__Strong、__w
循环引用机理
两个对象相互持有，这样就会造成循环引用，如下图所示
图中，对象A持有对象B，对象B持有对象A，相互持有，最终导致两个对象都不能释放。
即
block中循环引用问题
最普通的情况，由于block会对block中的对象进行持有操作,就相当于持有了其中的对象，而如果此时block中的对象又持有了该block，则会造成循环引用。如下：
typedef void(^block)();
@property (copy, nonatomic) block myBlock;
@property (copy, nonatomic) NSString *blockString;
- (void)testBlock;{
self.myBlock = ^() {
NSString *localString = self.blockString;
//2.NSString *localString = _blockString;
//3.[self doSomething];
};
}
调用以上三句均会造成循环引用，因为不管是通过self.blockString还是_blockString，或是函数调用[self doSomething]，因为只要 block中用到了对象的属性或者函数，block就会持有该对象而不是该对象中的某个属性或者函数。
当有someObj持有self对象，此时的关系图如下。
当someObj对象release self对象时，self和myblock相互引用，retainCount都为1，造成循环引用
解决：
__weak typeof(self) weakSelf = self;
self.myBlock = ^() {
NSString *localString = weakSelf.blockString;
};
使用__weak修饰self，使其在block中不被持有，打破循环引用。开始状态如下
当someObj对象释放self对象时，Self的retainCount为0，走dealloc，释放myBlock对象，使其retainCount也为0。
多个对象引用
其实以上循环引用的情况很容易发现，因为此时Xcode就会报警告。而发生在多个对象间的时候，Xcode就检测不出来了，这往往就容易被忽略。
//ClassB
@interface ClassB : NSObject
@property (strong, nonatomic) ClassA *objA;
- (void)doSomething;
@end
//ClassA
@property (strong, nonatomic) ClassB *objB;
@property (copy, nonatomic) block myBlock;
- (void)testBlockRetainCycle {
ClassB* objB = [[ClassB alloc] init];
self.myBlock = ^() {
[objB doSomething];
};
objB.objA = self;
}
解决方法：
- (void)testBlockRetainCycle {
ClassB* objB = [[ClassB alloc] init];
__weak typeof(objB) weakObjB = objB;
self.myBlock = ^() {
[weakObjB doSomething];
};
objB.objA = self;
}
将objA对象weak，使其不在block中被持有
注：以上使用__weak打破循环的方法只在ARC下才有效，在MRC下应该使用__block
或者，在block执行完后，将block置nil，这样也可以打破循环引用
- (void)testBlockRetainCycle {
ClassB* objB = [[ClassB alloc] init];
self.myBlock = ^() {
[objB doSomething];
};
objA.objA = self;
self.myBlock();
self.myBlock = nil;
}
这样做的缺点是，block只会执行一次，因为block被置nil了，要再次使用的话，需要重新赋值。
一些不会造成循环引用的block
在开发工程中，发现一些同学并没有完全理解循环引用，以为只要有block的地方就会要用__weak来修饰对象，这样完全没有必要，以下几种block是不会造成循环引用的。
大部分GCD方法
dispatch_async(dispatch_get_main_queue(), ^{
[self doSomething];
});
因为self并没有对GCD的block进行持有，没有形成循环引用。目前我还没碰到使用GCD导致循环引用的场景，如果某种场景self对GCD的block进行了持有，则才有可能造成循环引用。
block并不是属性值，而是临时变量
- (void)doSomething;{
[self testWithBlock:^{
[self test];
}];
}
- (void)testWithBlock:(void(^)())block;{
block();
}
- (void)test;{
NSLog(@"test");
}
这里因为block只是一个临时变量，self并没有对其持有，所以没有造成循环引用
block使用对象被提前释放（循环引用外其他问题）
看下面例子，有这种情况，如果不只是ClassA持有了myBlock，ClassB也持有了myBlock。
当ClassA被someObj对象释放后
此时，ClassA对象已经被释放，而myBlock还是被ClassB持有，没有释放；如果myBlock这个时被调度，而此时ClassA已经被释放，此时访问的ClassA将是一个nil对象（使用__weak修饰，对象释放时会置为nil），而引发错误。
另一个常见错误使用是，开发者担心循环引用错误（如上所述不会出现循环引用的情况），使用__weak。比如
__weak typeof(self) weakSelf = self;
dispatch_async(dispatch_get_main_queue(), ^{
[weakSelf doSomething];
});
此时导致doSomething直接无法执行，因为block作为参数传给dispatch_async时，系统会将block拷贝到堆上，而且block会持有block中用到的对象,因为dispatch_async并不知道block中对象会在什么时候被释放，为了确保系统调度执行block中的任务时其对象没有被意外释放掉，dispatch_async必须自己retain一次对象（即self），任务完成后再release对象（即self）。但这里使用__weak，使dispatch_async没有增加self的引用计数，这使得在系统在调度执行block之前，self可能已被销毁，但系统并不知道这个情况，导致block执行时访问已经被释放的self，而达不到预期的结果。
理解这点很重要，这是许多使用__weak,__stong的由来，实际的过程原理与block实现有关，下文会补充，这里先记住这点。
注：如果是在MRC模式下，使用__block修饰self,则此时block访问被释放的self，则会导致crash。如下：
// ClassA.m
- (void)test {
__weak MyClass* weakSelf = self;
double delayInSeconds = 10.0f;
dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delayInSeconds * NSEC_PER_SEC));
dispatch_after(popTime, dispatch_get_main_queue(), ^(void){
NSLog(@"%@", weakSelf);
});
}
// ClassB.m
- (void)doSomething {
NSLog(@"do something");
ClassA *objA = [[ClassA alloc] init];
[objA test];
}
运行结果
[5988:435396] do something
[5988:435396] self:(null)
解决方法：
对于这种场景，就不应该使用__weak来修饰对象，让dispatch_after对self进行持有，保证block执行时self还未被释放。
block执行过程中对象被释放
还有一种场景，在block执行开始时self对象还未被释放，而执行过程中，self被释放了，此时访问self时，就会发生错误。
对于这种场景，应该在block中对 对象使用__strong修饰，使得在block期间对 对象持有，block执行结束后，解除其持有。这也就是为什么许多使用block的地方内外要
- (void)testBlockRetainCycle {
ClassA* objA = [[ClassA alloc] init];
__weak typeof(objA) weakObjA = objA;
self.myBlock = ^() {
__strong typeof(weakObjA) strongWeakObjA = weakObjA;
[strongWeakObjA doSomething];
};
objA.objA = self;
}
注：此方法只能保证在block执行期间对象不被释放，如果对象在block执行执行之前已经被释放了，该方法也无效。
__block
讲到这里不得不提及一下__block。承接前面的例子，均是在block中使用其他对象的方法。实际应用中会有在block使用变量，或其他对象属性的情况。如下：
__block BOOL isOS = NO;
[testobj doSomethingBlock:^( ... ) {
...
isOS = YES;
}];
if(isOS){...}
else{...}
亦或是
__block NSObject *menuCopy = menu;
menu.doSomethingBlock = ^(NSMenuItem *_Nonnull item) {
[menuCopy closeMenu];
menuCopy = nil;
doSomethingBlock(item);
};
[menu showMenuToRect:rect ofView:view];
无论是在block中修改外部变量、或是对其他熟悉的操作。因为block在其他线程中执行，取值时是进行copy操作，如果是有self等引用则不会有问题，如果是外部变量或临时声明的对象，在block做处理操作时则要考虑，是否希望改变原来的值。这里的__block起到了原来c语言中&取地址，传递地址的作用。
这里的作用机理和block的机理有关，block本身的核心逻辑是C中的匿名方法，因为C语言中方法是可以作为属性来传递的，OC中将block需要使用的方法快作为匿名方法的熟悉，封装在一个结构体中。而这句__block则是将对于需要传递内存的属性/对象一同封装在这个结构体中。
不过我个人觉得，这种临时变量需要在block中进行处理，然后希望同时影响外部的需求。我认为在业务需求上是很少用到的，大家想避免还是很容易。
结论：
1.要注意block本身持有情况，及block内部的持有情况，尤其是类似“ block myBlock”等已经在类内部全局声明持有的block
2.block本身并不是属性值，而是临时变量，故不要一味的在weak中使用weak
3.在block外部声明的临时变量，需要在block内部继续使用时，要用__strong声明，来防止在进入block前，已经被释放掉了。
4.如果有临时变量/对象需要放到block中处理，且希望是Strong传递而非Copy传递则用__block修饰
小声bb：讲了这么多，其实很简单，遇到block，先看block是否全局引用了，如果全局引用了，则其内部的self等必然要weak处理。二要看内部是否使用了临时变量/对象的方法，如果使用了则要考虑是否需要使用strong防止对象过程释放。__block就是给临时变量，修改隐性的copy为strong。
本篇中许多内容引用自
https://www.jianshu.com/p/492be28d63c4
感谢🙏作者@HK_Hank
block原理部分大家感兴趣可以看
https://segmentfault.com/a/1190000018779727
https://www.jianshu.com/p/221d0778dcaa
https://www.jianshu.com/p/00a7ee0177ea
附上项目中常用宏，供大家参考使用
/**
weakify
*/
#ifndef weakify
#if DEBUG
#if __has_feature(objc_arc)
#define weakify(object) autoreleasepool {} __weak __typeof__(object) weak ## _ ## object = object;
#else
#define weakify(object) autoreleasepool {} __block __typeof__(object) block ## _ ## object = object;
#endif
#else
#if __has_feature(objc_arc)
#define weakify(object) try {} @finally {} {} __weak __typeof__(object) weak ## _ ## object = object;
#else
#define weakify(object) try {} @finally {} {} __block __typeof__(object) block ## _ ## object = object;
#endif
#endif
#endif
/**
strongify
*/
#ifndef strongify
#if DEBUG
#if __has_feature(objc_arc)
#define strongify(object) autoreleasepool {} __typeof__(object) object = weak ## _ ## object;
#else
#define strongify(object) autoreleasepool {} __typeof__(object) object = block ## _ ## object;
#endif
#else
#if __has_feature(objc_arc)
#define strongify(object) try {} @finally {} __typeof__(object) object = weak ## _ ## object;
#else
#define strongify(object) try {} @finally {} __typeof__(object) object = block ## _ ## object;
#endif
#endif
#endif
使用大致如下
@weakify(obj)
@weakify(self)
self.xxxxxBlock = ^(BOOL isBOOL) {
@strongify(obj)
[obj doSomething];
[weak_self doSomething];
};
