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。