iOS面试题整理---__weak和__strong在Block中的使用

iOS面试题整理---weak和strong在Block中的使用

【转载】iOS weak和strong在Block中的使用

1. __weak使用

1.1 ARC以后引入了__weak的概念来修饰Objective-C对象,使用这个关键字修饰的对象,对象的引用计数不会+1,这个关键字和__unsafe_unretained有些类似,只是在对象释放的时候__weak会将引用的对象置为nil,而__unsafe_unretained不会,这将会导致野指针的产生,所以一般情况下,我们一般不属于强引用某个对象的时候,可以使用__weak进行修饰,典型的例子就是代理.例如

class UICollectionView.h
@property (nonatomic, weak, nullable) id <UICollectionViewDelegate> delegate;

1.2 一个对象在声明的时候,如果什么修饰符都不写,默认是strong,就会导致引用计数加+1,当出了这个对象声明的scope,引用计数就会-1,如果引用计数为0,这个对象就会被释放.
当一个强引用的对象被Block捕获的时候,引用计数就会增加,当这个只有当这个Block被释放的时候这个强引用的对象的计数器才会回到原先的大小.
例如

void (^block)(void);
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        {
            TestObj *obj = [[TestObj alloc] init];
            NSLog(@"before block retainCount:%zd",[obj arcDebugRetainCount]);
            block = ^(){
                NSLog(@"TestObj对象地址:%@",obj);
            };
            NSLog(@"after block retainCount:%zd",[obj arcDebugRetainCount]);
        }
        block();
    }
    return 0;
}

打印的结果为:

DemoWeak[19005:6761339] before block retainCount:1
DemoWeak[19005:6761339] after block retainCount:3
DemoWeak[19005:6761339] TestObj对象地址:<TestObj: 0x602000006b30>

比较有意思的是引用计数并不是简单的+1,而是加2,这是由于block在创建的时候在栈上,而在赋值给全局变量的时候,被拷贝到了堆上,证明如下:

NSLog(@"堆%@",[block class]);
NSLog(@"栈%@",[^(){NSLog(@"TestObj对象地址:%@",obj);} class]);
DemoWeak[19026:6763489] 堆__NSMallocBlock__
DemoWeak[19026:6763489] 栈__NSStackBlock__

由于Block对对象的强引用,导致如果这个Block一直不释放,那么所强引用的对象也就无法释放,这样就会导致对象的dealloc方法无法执行,以前就遇到了这种对象不释放,但仍然发送通知的情况,找了好久,解决这个问题也很简单,我们只需要将Block将要强引用的对象,弱引用就可以了,代码如下

void (^block)(void);
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        {
            TestObj *obj = [[TestObj alloc] init];
            __weak TestObj *weakObj = obj;
            NSLog(@"before block retainCount:%zd",[obj arcDebugRetainCount]);
            block = ^(){
                NSLog(@"TestObj对象地址:%@",weakObj);
            };
            NSLog(@"after block retainCount:%zd",[obj arcDebugRetainCount]);
        }
        block();
    }
    return 0;
}

打印结果如下

DemoWeak[19065:6774290] before block retainCount:1
DemoWeak[19065:6774290] after block retainCount:1

可以看到弱引用前后,对象的计数器并没有什么改变.

刚开始学习Block的时候,总是觉得由于Block只是定义,而并没有执行,所以想当然的以为Block并没有对内部的引用对象有任何影响,知道看到了Block编译后的代码,下面就是编译后,截取的部分代码

从图片上可以看出block在声明的时候,就已经调用了初始化函数,保存了Block所捕获到的引用对象(注意,由于使用__weak,无法编译出.cpp源文件,所以在编译时候,我使用了__unsafe_unretained,除了上面说到他和__weak之间的区别,实验的结果都是一样的)

2. __strong使用

除了在Block外使用__weak对对象进行弱引用,我们偶尔还需要在Block内部对弱引用对象进行一次强引用,这是由于, 仅用__weak所修饰的对象,如果被释放,那么这个对象在Block执行的过程中就会变成nil,这就可能会带来一些问题,比如,数组,字典的插入.
正确的做法是,在Block执行的开始,检验弱引用的对象是否还存在,如果还存在,使用__strong进行强引用,这样,在Block执行的过程中,这个对象就不会被置为nil,而在Block执行完毕后,对象的引用计数就会-1,这样就不会导致对象无法释放.

Block从外界所捕获的对象和在Block内部强使用__strong强引用的对象,差别就在于一个是在定义的时候就会影响对象的引用计数(理由就是上面编译后的代码),一个是在Block运行的时候才强引用对象,执行完毕还是会-1

一般情况下,只使用__weak就能满足大部分的需求了,只有在多线程处理的时候,需要在Block使用下__strong修饰对象,因为,单个线程,要么执行Block的时候对象还没有被置为nil,那么直到Block被执行完毕,这个对象都不会被释放(释放也是需要线程调用函数的不是?),但是在多线程的情况下,就可能造成,在执行上半部分代码的时候,对象还在,而在执行下半部代码的时候对象已经被释放,下面是一个例子:

TestObj *obj = [[TestObj alloc] init];
__weak TestObj *weakObj = obj;
NSLog(@"before block retainCount:%zd",[obj arcDebugRetainCount]);
block = ^(){
    NSLog(@"TestObj对象地址:%@",weakObj);
    dispatch_async(dispatch_queue_create(DISPATCH_QUEUE_PRIORITY_DEFAULT, NULL), ^{
        
        for (int i = 0; i < 1000000; i++) {
            // 模拟一个耗时的任务
        }

        NSLog(@"耗时的任务 结束 TestObj对象地址:%@",weakObj);
    });
};
NSLog(@"after block retainCount:%zd",[obj arcDebugRetainCount]);
block();

打印结果:

DemoWeek[19247:6816518] before block retainCount:1
DemoWeek[19247:6816518] after block retainCount:1
DemoWeek[19247:6816518] TestObj对象地址:<TestObj: 0x602000006af0>
DemoWeek[19247:6816518] TestObj 对象已释放
DemoWeek[19247:6816544] 耗时的任务 结束 TestObj对象地址:(null)

可以看到在耗时任务执行前对象还是存在的,只是在执行完毕了后,对象被释放了,如果我们使用__strong修饰就可以避免这种情况

block = ^(){
    __strong  TestObj *strongObj = weakObj;
    if(! strongObj) return;
    NSLog(@"TestObj对象地址:%@",strongObj);
    dispatch_async(dispatch_queue_create(DISPATCH_QUEUE_PRIORITY_DEFAULT, NULL), ^{
        
        for (int i = 0; i < 1000000; i++) {
            // 模拟一个耗时的任务
        }

        NSLog(@"耗时的任务 结束 TestObj对象地址:%@",strongObj);
    });

打印结果:

DemoWeek[19280:6819437] before block retainCount:1
DemoWeek[19280:6819437] after block retainCount:1
DemoWeek[19280:6819437] TestObj对象地址:<TestObj: 0x602000006b30>
DemoWeek[19280:6819464] 耗时的任务 结束 TestObj对象地址:<TestObj: 0x602000006b30>
DemoWeek[19280:6819464] TestObj 对象已释放

总结:

__weak修饰的对象被Block引用,不会影响对象的释放,而__strong在Block内部修饰的对象,会保证,在使用这个对象在scope内,这个对象都不会被释放,出了scope,引用计数就会-1,且__strong主要是用在多线程运用中,若果只使用单线程,只需要使用__weak即可

注意：

除了在Block外使用__weak对对象进行弱引用,我们偶尔还需要在Block内部对弱引用对象进行一次强引用,这是由于, 仅用__weak所修饰的对象,如果被释放,那么这个对象在Block执行的过程中就会变成nil,这就可能会带来一些问题,比如,数组,字典的插入.
正确的做法是,在Block执行的开始,检验弱引用的对象是否还存在,如果还存在,再使用__strong进行强引用,