iOS Block的本质(四)

iOS Block的本质(四)

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

1. block内修改变量的值

int main(int argc, const char * argv[]) {
@autoreleasepool {
    int age = 10;
    Block block = ^ {
        // age = 20; // 无法修改
        NSLog(@"%d",age);
    };
    block();
}
return 0;
}
  1. 默认情况下block不能修改外部的局部变量。通过之前对源码的分析可以知道。
  2. age是在main函数内部声明的,说明age的内存存在于main函数的栈空间内部,但是block内部的代码在__main_block_func_0函数内部。__main_block_func_0函数内部无法访问age变量的内存空间,两个函数的栈空间不一样,__main_block_func_0内部拿到的age是block结构体内部的age,因此无法在__main_block_func_0函数内部去修改main函数内部的变量。

方式一:age使用static修饰。

  • 前文提到过static修饰的age变量传递到block内部的是指针,在__main_block_func_0函数内部就可以拿到age变量的内存地址,因此就可以在block内部修改age的值。

方式二:__block

  1. __block用于解决block内部不能修改auto变量值的问题,__block不能修饰静态变量(static) 和全局变量。
    • __block int age = 10;
  2. 编译器会将__block修饰的变量包装成一个对象,查看其底层c++源码。
  3. 上述源码中可以发现,首先被__block修饰的age变量声明变为名为age的__Block_byref_age_0结构体,也就是说加上__block修饰的话捕获到的block内的变量为__Block_byref_age_0类型的结构体。
  4. 通过下图查看__Block_byref_age_0结构体内存储哪些元素。
    • __isa指针 :__Block_byref_age_0中也有isa指针也就是说__Block_byref_age_0本质也一个对象。
    • __forwarding:__forwarding是__Block_byref_age_0结构体类型的,并且__forwarding存储的值为(__Block_byref_age_0 *)&age,即结构体自己的内存地址。
    • __flags :0
    • __size :sizeof(__Block_byref_age_0),即__Block_byref_age_0所占用的内存空间。
    • age :真正存储变量的地方,这里存储局部变量10。
    • 接着将__Block_byref_age_0结构体age存入__main_block_impl_0结构体中,并赋值给__Block_byref_age_0 *age;
    • 之后调用block,首先取出__main_block_impl_0中的age,通过age结构体拿到__forwarding指针,上面提到过__forwarding中保存的就是__Block_byref_age_0结构体本身,这里也就是age(__Block_byref_age_0),在通过__forwarding拿到结构体中的age(10)变量并修改其值。
    • 后续NSLog中使用age时也通过同样的方式获取age的值。
  5. 为什么要通过__forwarding获取age变量的值?
  • __forwarding是指向自己的指针。这样的做法是为了方便内存管理,之后内存管理章节会详细解释。
  • 到此为止,__block为什么能修改变量的值已经很清晰了。__block将变量包装成对象,然后在把age封装在结构体里面,block内部存储的变量为结构体指针,也就可以通过指针找到内存地址进而修改变量的值。

2. __block修饰对象类型

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        __block Person *person = [[Person alloc] init];
        NSLog(@"%@",person);
        Block block = ^{
            person = [[Person alloc] init];
            NSLog(@"%@",person);
        };
        block();
    }
    return 0;
}
  1. 生成c++源码分析
  1. 通过源码查看,将对象包装在一个新的结构体中。结构体内部会有一个person对象,不一样的地方是结构体内部添加了内存管理的两个函数__Block_byref_id_object_copy__Block_byref_id_object_dispose
  2. 上文提到当block中捕获对象类型的变量时,block中的__main_block_desc_0结构体内部会自动添加copy和dispose函数对捕获的变量进行内存管理。
  3. 那么同样的当block内部捕获__block修饰的对象类型的变量时,__Block_byref_person_0结构体内部也会自动添加__Block_byref_id_object_copy__Block_byref_id_object_dispose对被__block包装成结构体的对象进行内存管理。
  4. 当block内存在栈上时,并不会对__block变量产生内存管理。当blcok被copy到堆上时会调用block内部的copy函数,copy函数内部会调用_Block_object_assign函数,_\Block_object_assign函数会对__block变量形成强引用(相当于retain)
    • 首先通过下图看一下block复制到堆上时内存变化
  5. 当block被copy到堆上时,block内部引用的__block变量也会被复制到堆上,并且持有变量,如果block复制到堆上的同时,__block变量已经存在堆上了,则不会复制。
  6. 当block从堆中移除的话,就会调用dispose函数,也就是__main_block_dispose_0函数,__main_block_dispose_0函数内部会调用_Block_object_dispose函数,会自动释放引用的__block变量。
  7. block内部决定什么时候将变量复制到堆中,什么时候对变量做引用计数的操作。
  8. __block修饰的变量在block结构体中一直都是强引用,而其他类型的是由传入的对象指针类型决定。
  9. 通过下面代码深入的观察一下。 typedef void (^Block)(void); int main(int argc, const char * argv[]) { @autoreleasepool { int number = 20; __block int age = 10; NSObject *object = [[NSObject alloc] init]; __weak NSObject *weakObj = object; Person *p = [[Person alloc] init]; __block Person *person = p; __block __weak Person *weakPerson = p; Block block = ^ { NSLog(@"%d",number); // 局部变量 NSLog(@"%d",age); // __block修饰的局部变量 NSLog(@"%p",object); // 对象类型的局部变量 NSLog(@"%p",weakObj); // __weak修饰的对象类型的局部变量 NSLog(@"%p",person); // __block修饰的对象类型的局部变量 NSLog(@"%p",weakPerson); // __block,__weak修饰的对象类型的局部变量 }; block(); } return 0; }
  10. 将上述代码转化为c++代码查看不同变量之间的区别 struct __main_block_impl_0 { struct __block_impl impl; struct __main_block_desc_0* Desc; int number; NSObject *__strong object; NSObject *__weak weakObj; __Block_byref_age_0 *age; // by ref __Block_byref_person_1 *person; // by ref __Block_byref_weakPerson_2 *weakPerson; // by ref __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _number, NSObject *__strong _object, NSObject *__weak _weakObj, __Block_byref_age_0 *_age, __Block_byref_person_1 *_person, __Block_byref_weakPerson_2 *_weakPerson, int flags=0) : number(_number), object(_object), weakObj(_weakObj), age(_age->__forwarding), person(_person->__forwarding), weakPerson(_weakPerson->__forwarding) { impl.isa = &_NSConcreteStackBlock; impl.Flags = flags; impl.FuncPtr = fp; Desc = desc; } };
  11. 上述__main_block_impl_0结构体中看出,没有使用__block修饰的变量(object 和 weakObj)则根据他们本身被block捕获的指针类型对他们进行强引用或弱引用,而一旦使用__block修饰的变量,__main_block_impl_0结构体内一律使用强指针引用生成的结构体。
  12. 接着我们来看__block修饰的变量生成的结构体有什么不同。 struct __Block_byref_age_0 { void *__isa; __Block_byref_age_0 *__forwarding; int __flags; int __size; int age; }; struct __Block_byref_person_1 { void *__isa; __Block_byref_person_1 *__forwarding; int __flags; int __size; void (*__Block_byref_id_object_copy)(void*, void*); void (*__Block_byref_id_object_dispose)(void*); Person *__strong person; }; struct __Block_byref_weakPerson_2 { void *__isa; __Block_byref_weakPerson_2 *__forwarding; int __flags; int __size; void (*__Block_byref_id_object_copy)(void*, void*); void (*__Block_byref_id_object_dispose)(void*); Person *__weak weakPerson; };
  13. 如上面分析的那样,__block修饰对象类型的变量生成的结构体内部多了__Block_byref_id_object_copy和__Block_byref_id_object_dispose两个函数,用来对对象类型的变量进行内存管理的操作。而结构体对对象的引用类型,则取决于block捕获的对象类型的变量。weakPerson是弱指针,所以__Block_byref_weakPerson_2对weakPerson就是弱引用,person是强指针,所以__Block_byref_person_1对person就是强引用。 static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) { _Block_object_assign((void*)&dst->age, (void*)src->age, 8/*BLOCK_FIELD_IS_BYREF*/); _Block_object_assign((void*)&dst->object, (void*)src->object, 3/*BLOCK_FIELD_IS_OBJECT*/); _Block_object_assign((void*)&dst->weakObj, (void*)src->weakObj, 3/*BLOCK_FIELD_IS_OBJECT*/); _Block_object_assign((void*)&dst->person, (void*)src->person, 8/*BLOCK_FIELD_IS_BYREF*/); _Block_object_assign((void*)&dst->weakPerson, (void*)src->weakPerson, 8/*BLOCK_FIELD_IS_BYREF*/); }
  14. __main_block_copy_0函数中会根据变量是强弱指针及有没有被__block修饰做出不同的处理,强指针在block内部产生强引用,弱指针在block内部产生弱引用。被__block修饰的变量最后的参数传入的是8,没有被__block修饰的变量最后的参数传入的是3。
  15. 当block从堆中移除时通过dispose函数来释放他们。 static void __main_block_dispose_0(struct __main_block_impl_0*src) { _Block_object_dispose((void*)src->age, 8/*BLOCK_FIELD_IS_BYREF*/); _Block_object_dispose((void*)src->object, 3/*BLOCK_FIELD_IS_OBJECT*/); _Block_object_dispose((void*)src->weakObj, 3/*BLOCK_FIELD_IS_OBJECT*/); _Block_object_dispose((void*)src->person, 8/*BLOCK_FIELD_IS_BYREF*/); _Block_object_dispose((void*)src->weakPerson, 8/*BLOCK_FIELD_IS_BYREF*/); }

3. __forwarding指针

  1. 上面提到过__forwarding指针指向的是结构体自己。当使用变量的时候,通过结构体找到__forwarding指针,在通过__forwarding指针找到相应的变量。这样设计的目的是为了方便内存管理。通过上面对__block变量的内存管理分析我们知道,block被复制到堆上时,会将block中引用的变量也复制到堆中。
  2. 我们重回到源码中。当在block中修改__block修饰的变量时。 static void __main_block_func_0(struct __main_block_impl_0 *__cself) { __Block_byref_age_0 *age = __cself->age; // bound by ref (age->__forwarding->age) = 20; NSLog((NSString *)&__NSConstantStringImpl__var_folders_jm_dztwxsdn7bvbz__xj2vlp8980000gn_T_main_b05610_mi_0,(age->__forwarding->age)); }
  3. 通过源码可以知道,当修改__block修饰的变量时,是根据变量生成的结构体这里是__Block_byref_age_0找到其中__forwarding指针,__forwarding指针指向的是结构体自己因此可以找到age变量进行修改。
  4. 当block在栈中时,__Block_byref_age_0结构体内的__forwarding指针指向结构体自己。
  5. 而当block被复制到堆中时,栈中的__Block_byref_age_0结构体也会被复制到堆中一份,而此时栈中的__Block_byref_age_0结构体中的__forwarding指针指向的就是堆中的__Block_byref_age_0结构体,堆中__Block_byref_age_0结构体内的__forwarding指针依然指向自己。
  6. 此时当对age进行修改时 // 栈中的age __Block_byref_age_0 *age = __cself->age; // bound by ref // age->__forwarding获取堆中的age结构体 // age->__forwarding->age 修改堆中age结构体的age变量 (age->__forwarding->age) = 20;
  7. 通过__forwarding指针巧妙的将修改的变量赋值在堆中的__Block_byref_age_0中。
  8. 我们通过一张图展示__forwarding指针的作用
  1. 因此block内部拿到的变量实际就是在堆上的。当block进行copy被复制到堆上时,_Block_object_assign函数内做的这一系列操作。

4. 拓展

  1. 以下代码是否可以正确执行 int main(int argc, const char * argv[]) { @autoreleasepool { NSMutableArray *array = [NSMutableArray array]; Block block = ^{ [array addObject: @"5"]; [array addObject: @"5"]; NSLog(@"%@",array); }; block(); } return 0; }
    • 可以正确执行,因为在block块中仅仅是使用了array的内存地址,往内存地址中添加内容,并没有修改arry的内存地址,因此array不需要使用__block修饰也可以正确编译。
    • 因此当仅仅是使用局部变量的内存地址,而不是修改的时候,尽量不要添加__block,通过上述分析我们知道一旦添加了__block修饰符,系统会自动创建相应的结构体,占用不必要的内存空间。
  2. 上面提到过__block修饰的age变量在编译时会被封装为结构体,那么当在外部使用age变量的时候,使用的是__Block_byref_age_0结构体呢?还是__Block_byref_age_0结构体内的age变量呢?
    • 为了验证上述问题,同样使用自定义结构体的方式来查看其内部结构

    typedef void (^Block)(void); struct __block_impl { void *isa; int Flags; int Reserved; void *FuncPtr; }; struct __main_block_desc_0 { size_t reserved; size_t Block_size; void (*copy)(void); void (*dispose)(void); }; struct __Block_byref_age_0 { void *__isa; struct __Block_byref_age_0 *__forwarding; int __flags; int __size; int age; }; struct __main_block_impl_0 { struct __block_impl impl; struct __main_block_desc_0* Desc; struct __Block_byref_age_0 *age; // by ref }; int main(int argc, const char * argv[]) { @autoreleasepool { __block int age = 10; Block block = ^{ age = 20; NSLog(@"age is %d",age); }; block(); struct __main_block_impl_0 *blockImpl = (__bridge struct __main_block_impl_0 *)block; NSLog(@"%p",&age); } return 0; }

    1. 打印断点查看结构体内部结构
    1. 通过查看blockImpl结构体其中的内容,找到age结构体,其中重点观察两个元素:
    2. __forwarding其中存储的地址确实是age结构体变量自己的地址
    3. age中存储这修改后的变量20。
    4. 上面也提到过,在block中使用或修改age的时候都是通过结构体__Block_byref_age_0找到__forwarding在找到变量age的。
    5. 另外apple为了隐藏__Block_byref_age_0结构体的实现,打印age变量的地址发现其实是__Block_byref_age_0结构体内age变量的地址。
    1. 通过上图的计算可以发现打印age的地址同__Block_byref_age_0结构体内age值的地址相同。也就是说外面使用的age,代表的就是结构体内的age值。所以直接拿来用的age就是之前声明的int age。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

扫码关注云+社区

领取腾讯云代金券