iOC中block下的block、Strong、__w

作者: Sonoface | 来源:发表于2020-05-12 15:56 被阅读0次

循环引用机理

两个对象相互持有，这样就会造成循环引用，如下图所示

图中，对象A持有对象B，对象B持有对象A，相互持有，最终导致两个对象都不能释放。
即 $\color{#ea4335}{相互持有(强引用)，导致相互无法释放，形成循环引用}$

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，而达不到预期的结果。

$\color{#ea4335}{即block为了持有对象会将内部的对象先retain一次，完成之后再release}$
理解这点很重要，这是许多使用__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];
    };

iOC中block下的block、Strong、__w

循环引用机理

block中循环引用问题

多个对象引用

一些不会造成循环引用的block

block使用对象被提前释放（循环引用外其他问题）

block执行过程中对象被释放

__block

结论：

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

iOC中block下的__block、__Strong、__w

循环引用机理

block中循环引用问题

多个对象引用

一些不会造成循环引用的block

block使用对象被提前释放（循环引用外其他问题）

block执行过程中对象被释放

__block

结论：

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

iOC中block下的block、Strong、__w