美文网首页
iOS-深入研究Block

iOS-深入研究Block

作者: 似水流年_9ebe | 来源:发表于2021-08-21 15:35 被阅读0次

    前言

    在我们的实际开发中,Block的使用率相当之高,我们在使用Block的时候,会遇到各种各样的问题,比如经典的循环引用,那么这些问题到底是怎么产生的,我们又该如何去解决,这就需要我们对Block有深入的了解,才能更好的解决这些问题,今天我们就来深入分析一下Block。

    1 Block的类型

    我们知道Block分为全局Block栈Block堆Block。我们怎么区分或者判断是哪种Block呢,我们来分析下。

     int a = 10;
        void (^block)(void) = ^{
            //NSLog(@"robert - %d",a);
        };
    

    这是一个全局的Block,我们看下效果,如图:


    1

    我们把NSLog这行代码打开,再次运行,看下效果


    2
    这是一个堆Block。
    在ARC下,我们怎么打印出栈Block呢,我们把代码改成这样
     int a = 10;
       void (__weak ^block)(void) = ^{
            NSLog(@"robert - %d",a);
        };
    

    再次运行,如图所示

    3

    这是一个栈Block。
    Block类型划分,具体点,我们该怎么区分,如下所示,

    GlobalBlock

    • 位于全局区。
    • 在Block内部不使用外部变量,或者只使用静态和全局变量。

    MallocBlock

    • 位于堆区。
    • 在Block内部使用局部变量或者OC属性,并且赋值给强引用或者Copy修饰的变量。

    StackBlock

    • 位于栈区。
    • 与MallocBlock一样,可以在内部使用局部变量或者属性,但是不能赋值给强引用或者Copy修饰的变量。

    全局Block比较好区分,MallocBlock和StackBlock不易区分, 下面我们来看这样一段代码

    - (void)blockRetaincount{
        NSObject *objc = [NSObject new];
        NSLog(@"%ld",CFGetRetainCount((__bridge CFTypeRef)(objc)));
        void(^strongBlock)(void) = ^{
            NSLog(@"---%ld",CFGetRetainCount((__bridge CFTypeRef)(objc)));
        };
        strongBlock();
    
        void(^__weak weakBlock)(void) = ^{ // + 1
            NSLog(@"---%ld",CFGetRetainCount((__bridge CFTypeRef)(objc)));
        };
        weakBlock();
        
        void(^mallocBlock)(void) = [weakBlock copy];
        mallocBlock();
    }
    

    请问这里的打印是多少?
    我们运行一下,看下效果,如图


    4

    为什么结果是这样呢的?需要我们具体分析下。

    • *NSObject objc = [NSObject new];这里之后obj的引用计数为1

    • void(^strongBlock)(void) = ^{
      NSLog(@"---%ld",CFGetRetainCount((__bridge CFTypeRef)(objc)));
      }; 这是为什么是3呢,因为strongBlock外部捕获了objc,进行了copy操作,引用计数+1,strongBlock是一个MallockBlock,会进行强持有,从栈上拷贝堆上,这个时候堆上的对象引用计数再次+1,就变成了3。

    • void(^__weak weakBlock)(void) = ^{ // + 1
      NSLog(@"---%ld",CFGetRetainCount((__bridge CFTypeRef)(objc)));
      }; 这是一个栈Block,因为weakBlock外部捕获了objc,进行了copy操作,引用计数+1 ,但是它是一个栈Block,不会从栈上拷贝堆上,所以这里打印4。

    • void(^mallocBlock)(void) = [weakBlock copy]; 这里对weakBlock进行一次copy操作,从栈上拷贝到堆上,这个时候堆上的对象引用计数+1,所以这里打印5。

    我们接着再看一段代码,如下所示

    - (void)blockCopy{
        int a = 0;
        void(^ __weak weakBlock)(void) = ^{
            NSLog(@"-----%d", a);
        };
        struct _RoBlock *blc = (__bridge struct _RoBlock *)weakBlock;
        id __strong strongBlock = weakBlock;
        blc->invoke = nil;
        void(^strongBlock1)(void) = strongBlock;
        strongBlock1();
    }
    
    

    这段代码的执行结果是什么?
    我们来运行下,看下效果,如图

    5
    这里闪退了,我们来分析下。
    blc->invoke这里的invoke进行调用执行。

    struct _RoBlock *blc = (__bridge struct _RoBlock *)weakBlock; 这里把weakBlock进行强转。
    id __strong strongBlock = [weakBlock copy]; 这里把weakBlock进行copy操作。
    blc->invoke = nil; 把blc的invko置空。
    void(^strongBlock1)(void) = strongBlock;这段代码只是强转一次,把strongBlock具有block的特性,可以调用执行。
    说明weakBlock强转成blc时,他们还是指向同一块内存区域,blc的invoke为nil,那么weakBlock的invoke也是nil,所以这里调用的时候闪退。

    如何来解决呢,我们可以进行copy操作,id __strong strongBlock = weakBlock; 改成
    id __strong strongBlock = [weakBlock copy]; 我们再试下,如图

    6
    这样就就正常了,一定要在blc->invoke = nil;之前进行copy操作。

    我们再分析一段这代码,如下所示

    - (void)blockDemo{
    //    NSObject *a = [NSObject alloc];
        int a = 0;
        void(^__weak weakBlock)(void) = nil;
        {
            void(^__weak strongBlock)(void) = ^{
                NSLog(@"strongBlock ---%d", a);
            };
            weakBlock = strongBlock;
            NSLog(@"1");
        }
        weakBlock();
    }
    

    请问这段代码的执行结果是什么?
    我们来运行下,看下效果,如图


    6

    我们分析下它的执行流程是什么。

    • void(^__weak weakBlock)(void) = nil;这是一个栈Block
    • void(^__weak weakBlock)(void) = nil;
      {
      void(^__weak strongBlock)(void) = ^{
      NSLog(@"strongBlock ---%d", a);
      };
      weakBlock = strongBlock;
      NSLog(@"1");
      }
      weakBlock();
      }这里一个代码块,跟void(^__weak weakBlock)(void) = nil;无关
    • 在代码块中strongBlock是一个栈Block
    • 把strongBlock给了weakBlock, weakBlock也是一个栈Block
    • 栈Block的生命周期是在blockDemo这个方法中,也就是说只有出了这个方法,这个栈Block的生命周期才会结束,所以这里运行是正常的。

    我们改下代码,反* void(^__weak strongBlock)(void) = ^{改成 * void(^strongBlock)(void) = ^{ ,看下运行效果,如图

    7
    这里闪退了。
    原因分析Block默认是强引用的,这里是在堆区,它的生命周生期是在代码块中,出了代码块,它就会被锁毁,weakBlock = strongBlock;赋值后,weakBlock也是在堆区,所以这里调用weakBlock()就会闪退。
    我把weakBlock = strongBlock;改成weakBlock = [strongBlock copy];同样会闪退,原因同上,因为也是在堆区,出了代码块,销毁了。

    Block循环引用的分析

    8
    我们看下这张图,
    A对于进行B持有, A会对B进行引用计数+1的操作,当B要想释放掉的,需要等待A发送realses信号,如果B的引用计数为0的时候,dealloc就会被调用,只有当A在dealloc的时候会发送信号给B。
    9
    这张图描述了,A持有B,B也同时持有了A,这个时候就构成了无法释放的循环,因为B的释掉依赖A的释放,A的释放又依赖的B的释放,产生了循环引用。

    我们先来段代码,案例1

    - (void)test1 {
        self.name = @"robert";
        self.block = ^(void) {
            NSLog(@"%@", self.name);
        };
        self.block();
    }
    
    - (void)dealloc{
        NSLog(@"dealloc走你");
    }
    

    我们运行一下,看下dealloc是否调用了,如图

    10
    这里没有打印,说明这里产生循环引用,
    这段代码,案例2
    [UIView animateWithDuration:1 animations:^{
            NSLog(@"%@", self.name);
        }];
    

    运行效果,如图


    1

    这里可以看出调用了dealloc,所以没有产生循环引用,这是为什么,我们分析下。

    案例1中,self->block->self 产生循环引用
    __weak typedef(self) weakSelf = self;使用weak指针来解决
    我们再改一下代码,如下

    - (void)test1 {
        __weak typeof(self)weakSelf = self;
      self.name = @"robert";
      self.block = ^(void) {
          dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)3*NSEC_PER_SEC), dispatch_get_main_queue(), ^{
              NSLog(@"name=%@", weakSelf.name);
          });
      };
      self.block();
    }
    
    

    看下它的执行效果,如图

    11
    name的值打印出来了空,这是为什么呢,我们只不过延迟几秒种调用而已,发生了什么事情?
    分析,当我们返回上个页面时,self被释放掉了,weakSelf也被释放掉了,这个时候再调用就是nil。
    我们可以通过__strong __typeof(weakSelf)strongSelf = self;来解决,如代码所示
    - (void)test1 {
        __weak typeof(self)weakSelf = self;
        self.name = @"robert";
        self.block = ^(void) {
            __strong __typeof(weakSelf)strongSelf = weakSelf;
            dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)3*NSEC_PER_SEC), dispatch_get_main_queue(), ^{
                NSLog(@"name=%@", strongSelf.name);
            });
        };
        self.block();
    }
    
    

    运行结果如下

    12
    这里运行就正常了。
    也就是说通过weak-strong-dance的方法解决。
    strongSelf虽然是强引用,是个临时变量,它的生命周期是在block的范围内,会自动释放。
    我们再来讲第二种方示,代码如下:
     __block SecondViewController *vc = self;
        self.name = @"robert";
        self.block = ^(void) {
            dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)3*NSEC_PER_SEC), dispatch_get_main_queue(), ^{
                NSLog(@"name=%@", vc.name);
                vc = nil;
            });
        };
        self.block();
    }
    

    运行结果,如图


    13

    vc被self.block持有了,但是我们把vc置空,断开了循环。
    self->block->vc->self,vc=nil断开了循环链。
    对外部变量操作加上__block的才能修改,后续会详细讲。
    当然我们还可以通过传参的方式来解决。

    我们再来看一段代码,如下所示:

    static SecondViewController *staticSelf_;
    - (void)blockWeakStatic {
        __weak typeof(self) weakSelf = self;
        staticSelf_ = weakSelf;
    }
    - (void)dealloc{
        NSLog(@"dealloc走你");
    }
    

    请问这里运行效果是什么,会不会产生循环引用?
    分析结果:这里肯定会产生循环引用,weakSelf->self,staticSelf->weakSelf,staticSelf是个全局静态变量,不会自动释放,所以这里产生了循环引用。
    我们来运行下,如图

    14
    这里发现dealloc没有调用,所以产生循环引用了。
    这里的weakSelf其实就是Self,我们断点打印一下,如图
    15

    这里可以看出,selfweakSelf、"staticSelf_"是指向同一块内存区域,也就是说weakSelfself是映射关系,他们三个又构成了循环链,所以就产生了循环引用。

    我们接着再分析一代码,如下

    - (void)block_weak_strong {
        __weak typeof(self) weakSelf = self;
        self.doWork = ^{
            __strong typeof(self) strongSelf = weakSelf;
            weakSelf.doStudent = ^{
                NSLog(@"111111111----- %@", strongSelf);
            };
           weakSelf.doStudent();
        };
       self.doWork();
    }
    
    

    请问这段代码的是否会产生循环引用?
    答案是肯定会产生循环引用。
    我们运行一,先看下结果,如图


    16

    上图已经说明了问题,会产生循环引用,究竟是为什么,我们来看下。

    • self.doWork对self持有
    • __strong typeof(self) strongSelf = weakSelf;
      weakSelf.doStudent = ^{
      NSLog(@"111111111----- %@", strongSelf);
      };
      weakSelf.doStudent();这里strongSelf对weakSelf持有,strongSelf虽然是临时变量,但是它的生命周期是在doWork这个block中,在strongSelf释放前,会执行上述代码,doStudent是会对strongSelf进行持有,捕获进去,对strongSelf引用计数+1操作,也就是说strongSelf的引用计数是2了,虽然在doWork这个block结束时会-1操作,但是还是无法释放这个strongSelf
    • 我们可以在NSLog(@"111111111----- %@", strongSelf);代码下面加入strongSelf=nil,断开循环链来解决。

    结语

    这篇文章结合实际应用讲述的Block的类型,循环引用的产生,以及如何解决这些问题,如有疑问,大家可以相互交流学习。

    相关文章

      网友评论

          本文标题:iOS-深入研究Block

          本文链接:https://www.haomeiwen.com/subject/wuxxiltx.html