Block对象变量捕获(三)

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Block对象变量捕获(三)相关的知识,希望对你有一定的参考价值。

参考技术A 前面已经说过Block对基本类型变量的捕获,现在来看看Block对对象变量的捕获。先看看下面几个问题

1、对象的局部变量捕获和基本数据类型有点区别,对象的局部auto变量捕获是指针捕获不是值捕获,所以捕获的内容会受外部变量的影响
2、因为block捕获了auto变量所以block是NSStackBlock,在ARC下将block赋值给__strong指针时会自动将栈上的block复制到堆上,block由NSStackBlock变为NSMallocBlock

1、这里Person虽然是局部变量,但是不是在离开作用域时(离开大括号)被释放,因为Person在被block捕获时被block强引用了,引用计数加了1,只有当引用计数为0时才会被释放。当block调用完从堆上移除时,会调用block内部的dispose函数,dispose函数内部会调用_Block_object_dispose函数,_Block_object_dispose函数会自动释放引用的auto变量(release),person的引用计数减1,此时person的引用计数为0被释放
2、block为NSMallocBlock的原因与问题一一样,这里需要说的是,只有在NSMallocBlock下才会对auto变量产生强引用,如果block是在栈上,将不会对auto变量产生强引用。
如果block被拷贝到堆上,会调用block内部的copy函数,copy函数内部会调用_Block_object_assign函数,_Block_object_assign函数会根据auto变量的修饰符(__strong、__weak、__unsafe_unretained)做出相应的操作,形成强引用(retain)或者弱引用

在问题二中有说到,堆上的Block会根据auto变量的修饰符(__strong、__weak、__unsafe_unretained)做出相应的操作,形成强引用(retain)或者弱引用。这里的person的修饰符为weak,所以block会对其产生弱引用,引用计数不会加1,当出作用域时person会被释放

1、self为对象局部auto变量,所以是指针捕获,内部的值会受外部的影响
2、block对self产生了一个强引用

Block变量捕获详解(一)
Block的三种类型(二)
__block修饰符(四)
Block循环引用(五)

# iOS Block的本质

iOS Block的本质(三)

  • 上一篇文章iOS Block的本质(二)中已经介绍过block变量的捕获,本文继续探寻block的本质。

1. block对对象变量的捕获,ARC 环境

  1. block一般使用过程中都是对对象变量的捕获,那么对象变量的捕获同基本数据类型变量相同吗?

  2. 查看一下代码思考:当在block中访问的为对象类型时,对象什么时候会销毁?

    // ARC环境下代码
    typedef void (^Block)(void);
    int main(int argc, const char * argv[]) {
        @autoreleasepool {
            Block block;
            {
                Person *person = [[Person alloc] init];
                person.age = 10;
    
                block = ^{
                    NSLog(@"------block内部%d",person.age);
                };
            } // 执行完毕,person没有被释放
            NSLog(@"--------");
        } // person 释放
        return 0; 
    }
    
  3. 大括号执行完毕之后,person依然不会被释放。上一篇文章提到过,person为aotu变量,传入的block的变量同样为person,即block有一个强引用引用person,所以block不被销毁的话,peroson也不会销毁。

    struct __main_block_impl_0 {
      struct __block_impl impl;
      struct __main_block_desc_0* Desc;
      Person * person;
      __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, Person *_person, int flags=0) : person(_person) {
        impl.isa = &_NSConcreteStackBlock;
        impl.Flags = flags;
        impl.FuncPtr = fp;
        Desc = desc;
      }
    };
    

2. block对对象变量的捕获,ARC 环境

  1. 在MRC环境下即使block还在,person却被释放掉了。因为MRC环境下block在栈空间,栈空间对外面的person不会进行强引用。

    //MRC环境下代码
    int main(int argc, const char * argv[]) {
        @autoreleasepool {
            Block block;
            {
                Person *person = [[Person alloc] init];
                person.age = 10;
                block = ^{
                    NSLog(@"------block内部%d",person.age);
                };
                [person release];
            } // person被释放
            NSLog(@"--------");
        }
        return 0;
    }
    
  2. block调用copy操作之后,person不会被释放。

    block = [^{
       NSLog(@"------block内部%d",person.age);
    } copy];
    
  3. 上文中也提到过,只需要对栈空间的block进行一次copy操作,将栈空间的block拷贝到堆中,person就不会被释放,说明堆空间的block可能会对person进行一次retain操作,以保证person不会被销毁。堆空间的block自己销毁之后也会对持有的对象进行release操作。

  4. 也就是说栈空间上的block不会对对象强引用,堆空间的block有能力持有外部调用的对象,即对对象进行强引用或去除强引用的操作。

  5. 在__weak修饰之后,person在作用域执行完毕之后就被销毁了。

    typedef void (^Block)(void);
    int main(int argc, const char * argv[]) {
        @autoreleasepool {
            Block block;
            {
                Person *person = [[Person alloc] init];
                person.age = 10;
    
                __weak Person *weakPerson = person;
                block = ^{
                    NSLog(@"------block内部%d",waekPerson.age);
                };
            }
            NSLog(@"--------");
        }
        return 0;
    }
    
  6. 将代码转化为c++来看一下上述代码之间的差别。

    • 在转换C++代码时用__weak修饰变量,需要告知编译器使用ARC环境及版本号否则会报错,添加说明-fobjc-arc -fobjc-runtime=ios-8.0.0
    • xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc -fobjc-arc -fobjc-runtime=ios-8.0.0 main.m
     struct __main_block_impl_0 {
       struct __block_impl impl;
       struct __main_block_desc_0* Desc;
       Person *__weak person;
       __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, Person *__weak _person, int flags=0) : person(_weakPerson) {
         impl.isa = &_NSConcreteStackBlock;
         impl.Flags = flags;
         impl.FuncPtr = fp;
         Desc = desc;
       }
     };
    
  7. 用__weak修饰的变量,在生成的__main_block_impl_0中也是使用__weak修饰捕获。

3. __main_block_copy\\_0__main_block_dispose_0函数分析:

  1. 当block中捕获对象类型的变量时,我们发现block结构体__main_block_impl_0的描述结构体__main_block_desc_0中多了两个参数copy和dispose函数,查看源码:

  2. copy和dispose函数中传入的都是__main_block_impl_0结构体本身。

  3. copy本质就是__main_block_copy_0函数,__main_block_copy_0函数内部调用_Block_object_assign函数,_Block_object_assign中传入的是person对象的地址,person对象,以及8。

  4. dispose本质就是__main_block_dispose_0函数,__main_block_dispose_0函数内部调用_Block_object_dispose函数,_Block_object_dispose函数传入的参数是person对象,以及8。

4. _Block_object_assign函数调用时机及作用

  1. 当block进行copy操作的时候就会自动调用__main_block_desc_0内部的__main_block_copy_0函数,__main_block_copy_0函数内部会调用_Block_object_assign函数。

  2. _Block_object_assign函数会自动根据__main_block_impl_0结构体内部的person是什么类型的指针,对person对象产生强引用或者弱引用。可以理解为_Block_object_assign函数内部会对person进行引用计数器的操作,如果__main_block_impl_0结构体内person指针是__strong类型,则为强引用,引用计数+1,如果__main_block_impl_0结构体内person指针是__weak类型,则为弱引用,引用计数不变。

5. _Block_object_dispose函数调用时机及作用

  1. 当block从堆中移除时就会自动调用__main_block_desc_0中的__main_block_dispose_0函数,__main_block_dispose_0函数内部会调用_Block_object_dispose函数。

  2. _Block_object_dispose会对person对象做释放操作,类似于release,也就是断开对person对象的引用,而person究竟是否被释放还是取决于person对象自己的引用计数。

6. 总结

  1. 一旦block中捕获的变量为对象类型,block结构体中的__main_block_desc_0会出两个参数copy和dispose。因为访问的是个对象,block希望拥有这个对象,就需要对对象进行引用,也就是进行内存管理的操作。比如说对对象进行retarn操作,因此一旦block捕获的变量是对象类型就会会自动生成copy和dispose来对内部引用的对象进行内存管理。

  2. 当block内部访问了对象类型的auto变量时,如果block是在栈上,block内部不会对person产生强引用。不论block结构体内部的变量是__strong修饰还是__weak修饰,都不会对变量产生强引用。

  3. 如果block被拷贝到堆上。copy函数会调用_Block_object_assign函数,根据auto变量的修饰符(__strong,__weak,unsafe_unretained)做出相应的操作,形成强引用或者弱引用

  4. 如果block从堆中移除,dispose函数会调用_Block_object_dispose函数,自动释放引用的auto变量。

7. 拓展

  1. 下列代码person在何时销毁?在person 类中重写 delloc 方法

    - (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
    {
        Person *person = [[Person alloc] init];
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
            NSLog(@"%@",person);
        });
        NSLog(@"touchBegin----------End");
    }
    
    // Log : 打印结果 : touchBegin----------End
    // Log :打印结果 : <Person: 0x6080000080d0>
    // Log :打印结果 : person 对象调用 delloc
    
    • 上文提到过ARC环境中,block作为GCD API的方法参数时会自动进行copy操作,因此block在堆空间,并且使用强引用访问person对象,因此block内部copy函数会对person进行强引用。当block执行完毕需要被销毁时,调用dispose函数释放对person对象的引用,person没有强指针指向时才会被销毁。
  2. 下列代码person在何时销毁 ?

    - (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
    {
        Person *person = [[Person alloc] init];
    
        __weak Person *weakPerson = person;
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
            NSLog(@"%@",weakPerson);
        });
        NSLog(@"touchBegin----------End");
    }
    // Log : 打印结果 : touchBegin----------End
    // Log :打印结果 : person 对象调用 delloc
    // Log :打印结果 : null
    // 结果是 person 先销毁才执行block 打印结果为 null
    
    • block中对weakPerson为__weak弱引用,因此block内部copy函数会对person同样进行弱引用,当大括号执行完毕时,person对象没有强指针引用就会被释放。因此block块执行的时候打印null。
  3. 通过示例代码进行总结。

    - (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
    {
        Person *person = [[Person alloc] init];
    
        __weak Person *weakPerson = person;
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    
            NSLog(@"weakPerson ----- %@",weakPerson);
    
            dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
                NSLog(@"person ----- %@",person);
            });
        });
        NSLog(@"touchBegin----------End");
    }
    // Log : 打印结果 : touchBegin----------End
    // Log :1s 后 打印结果 : weakPerson -> <Person: 0x608000006050>
    // Log :3s 后 打印结果 : person -> <Person: 0x608000006050>
    // Log :打印结果 : person 对象调用 delloc
    
    - (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
    {
        Person *person = [[Person alloc] init];
    
        __weak Person *waekP = person;
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    
            NSLog(@"person ----- %@",person);
    
            dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
                NSLog(@"weakP ----- %@",waekP);
            });
        });
        NSLog(@"touchBegin----------End");
    }
    // Log : 打印结果 : touchBegin----------End
    // Log :1s 后 打印结果 : person -> <Person: 0x608000006050>
    // Log :打印结果 : person 对象调用 delloc
    // Log :3s 后 打印结果 : weakPerson -> null
    

以上是关于Block对象变量捕获(三)的主要内容,如果未能解决你的问题,请参考以下文章

【OC语法】block的循环引用

深入理解Block

__block修饰符(四)

iOS block的变量捕获(capture)

闭包与block-捕获变量差异

闭包与block-捕获变量差异