经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 移动开发 » iOS » 查看文章
block本质探寻七之内存管理
来源：cnblogs　　作者：春天里的花骨朵　　时间：2019/1/18 9:24:30　　对本文有异议

说明：

<1>阅读本问，请参照block前述文章加以理解；

<2>环境：ARC；

<3>变量类型：基本数据类型或者对象类型的auto局部变量；

一、三种情形

//代码

  1. void test1()
  2. {
  3.     int num = 10;
  4.     __block int age = 20;
  5.     Person *per = [[Person alloc] init];
  6.     void(^block)(void) = ^{
  7.         NSLog(@"%d %d %p", num, age, per);
  8.     };
  9.     block();
  10. }

//打印

  1. 2019-01-16 15:42:38.974947+0800 MJ_TEST[2405:192414] 10 20 0x100654220
  2. 2019-01-16 15:42:38.975258+0800 MJ_TEST[2405:192414] -[Person dealloc]
  3. Program ended with exit code: 0

//clang：xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc -fobjc-arc -fobjc-runtime=ios-9.0.0 main.m

  1. struct __Block_byref_age_0 {
  2.   void *__isa;
  3. __Block_byref_age_0 *__forwarding;
  4.  int __flags;
  5.  int __size;
  6.  int age;
  7. };
  10. struct __test1_block_impl_0 {
  11.   struct __block_impl impl;
  12.   struct __test1_block_desc_0* Desc;
  13.   int num;
  14.   Person *__strong per;
  15.   __Block_byref_age_0 *age; // by ref
  16.   __test1_block_impl_0(void *fp, struct __test1_block_desc_0 *desc, int _num, Person *__strong _per, __Block_byref_age_0 *_age, int flags=0) : num(_num), per(_per), age(_age->__forwarding) {
  17.     impl.isa = &_NSConcreteStackBlock;
  18.     impl.Flags = flags;
  19.     impl.FuncPtr = fp;
  20.     Desc = desc;
  21.   }
  22. };
  25. static void __test1_block_copy_0(struct __test1_block_impl_0*dst, struct __test1_block_impl_0*src) {_Block_object_assign((void*)&dst->age, (void*)src->age, 8/*BLOCK_FIELD_IS_BYREF*/);_Block_object_assign((void*)&dst->per, (void*)src->per, 3/*BLOCK_FIELD_IS_OBJECT*/);}
  28. static void __test1_block_dispose_0(struct __test1_block_impl_0*src) {_Block_object_dispose((void*)src->age, 8/*BLOCK_FIELD_IS_BYREF*/);_Block_object_dispose((void*)src->per, 3/*BLOCK_FIELD_IS_OBJECT*/);}
  31. static struct __test1_block_desc_0 {
  32.   size_t reserved;
  33.   size_t Block_size;
  34.   void (*copy)(struct __test1_block_impl_0*, struct __test1_block_impl_0*);
  35.   void (*dispose)(struct __test1_block_impl_0*);
  36. }
  40. void test1()
  41. {
  42.     int num = 10;
  43.     __attribute__((__blocks__(byref))) __Block_byref_age_0 age = {(void*)0,(__Block_byref_age_0 *)&age, 0, sizeof(__Block_byref_age_0), 20};
  44.     Person *per = ((Person *(*)(id, SEL))(void *)objc_msgSend)((id)((Person *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("Person"), sel_registerName("alloc")), sel_registerName("init"));
  45.     void(*block)(void) = ((void (*)())&__test1_block_impl_0((void *)__test1_block_func_0, &__test1_block_desc_0_DATA, num, per, (__Block_byref_age_0 *)&age, 570425344));
  46.     ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
  47. }

分析：根据前述文章可知

<1>ARC模式下，block对象（等号右边大括号）被强指针（等号左边）变量持有（默认为strong）时，系统会自动将block对象从栈区copy到堆区；

<2>当访问实例对象或者__block修饰的基础数据类型变量时，block对象结构体中自动会增加两个函数指针——copy和dispose，分别指向__test1_block_copy_0函数和__test1_block_dispose_0函数；

<3>__block修饰的基础数据类型的变量，系统会自动生成一个新的对象（__Block_byref_age_0），block对象通过该新的对象指针变量（__Block_byref_age_0 *age）来访问基础数据类型变量（int age）；

<4>num：直接被block捕捉到其结构体内部，随block一起copy到堆区；其随block对象本身一起销毁（不管是栈区的block还是堆区的block）；

<5>per：类对象的访问，当block对象被copy到堆区时，block对象会通过copy函数指针来调用__test1_block_copy_0函数完成对per对象的拷贝；同时此时堆区的block对象会根据该类对象的类型（strong还是weak）来决定对其强引用还是弱引用；

说明：所谓的强引用，是指指针指向某个对象（实质为，存放指针变量的内存指向对象的内存）；所谓的指向，即是对该对象的引用计数加1即retain操作（即此时该指针持有该对象），但是一个对象可能被多个指针持有，因此realease并不必然导致对象销毁（内存回收）而只是被释放即某个指针变量不再指向（持有）该内存区域，只有当对象的引用计数为0时，系统才会自动回收其内存；

注：引用计数为对象的属性，而非指针；

<6>__block修饰的基本数据类型的变量和对象类型变量，block被拷贝时，都会通过调用__test1_block_copy_0函数中_Block_object_assign函数完成对自身的拷贝——其中，_Block_object_assign函数的第三个参数，8表示由__block修饰的基本数据类型变量，3表示访问的事对象类型变量（那么，__block修饰的对象类型是多少呢？往下看）；

当block对象销毁时，二者都是通过调用__test1_block_dispose_0函数中的_Block_object_dispose函数来被销毁；

问题：为什么要增加copy和dispose两个函数指针呢？因为block对象要持有上述两种对象（__block修饰的基本数据类型生成的对象和per实例对象），那么自然要对其进行内存管理，达到持有/释放的可控目的；

因此，__block修饰生成的对象（会随着block的copy而一起被copy到堆区，而拷贝后的栈区的结构体依然会存在，只不过其作用域结束后，系统会对其内存自动回收），block对象要对其持有，肯定是强引用，否则弱引用，该对象的内存管理不受控制，那么block内部修改变量的值存在极大风险——这点没问题；

补充：__weak不能修饰基础类型变量

如上，我么知道，__weak仅能修饰对象类型变量和block指针类型——为什么？

以上我们已经分析过，__strong和__weak：前者指针持有对象达到对该对象内存管理可控的目的（只要该对象的引用计数>0，其内存就不可能被回收，指针就可以合法指向该内存），会进行retain操作即对象的retainCount会自动+1；后者不持有，该对象的内存管理不可控（什么时候释放，跟该指针没关系），不会retain，对象的引用计数不会自动+1；

所以，__strong和__weak修饰的目的是对堆区的内存管理是否管控，而只有对象类型的变量（在堆区创建）才会有管控的问题，基础数据类型变量起始是在栈区存储，其内存（创建/回收）由系统自动管理；

 

二、__forwarding指针

我们在前面的文章提到，block对int类型的age变量的访问，为什么还要通过__forwarding指针而不是直接访问__Block_byref_age_0结构体中的age变量呢？

 

 分析：

<1>__forwarding指针本身是指向__Block_byref_age_0结构体本身；第一个age又是__Block_byref_age_0结构体类型的指针；第二个age是__Block_byref_age_0结构体中int型成员变量；

<2>在栈区：age->__forwarding->age <=> age->age 没有任何问题；但是在堆区：因为block对象结构体会被copy到堆区，而原先留在栈区的block中的__forwarding指针会自动指向堆区的__Block_byref_age_0结构体；

<3>从上述分析，我们很清楚地知道，将__Block_byref_age_0结构体一并copy到堆区的目的就是堆区的block对象强引用该结构体，所以指向堆区的block对象的各类指针（包括对象本身）都可以通过该block对象达到对__Block_byref_age_0结构体中age变量值的改变等操作的目的，而不必担心int型age变量内存随时会被系统回收的风险

————问题来了：如果栈区的指针或者block对象本身要对age变量的值进行修改，是要面临该风险的，那如何规避呢？

就是通过__forwarding指针，因为此时栈区的_Block_byref_age_0结构体中的__forwarding指针变量是指向堆区的_Block_byref_age_0结构体，除非堆区_Block_byref_age_0结构体内存被手动销毁，否则会一直存在；

//图解

 

 

三、__block修饰对象类型变量

//代码

  1. void test2()
  2. {
  3.     Person *per = [[Person alloc] init];
  4.     per.age = 20;
  5.     __block Person *blockPer = per;
  6.     void(^block)(void) = ^{
  7.         blockPer.age = 30;
  8.         NSLog(@"%d", blockPer.age);
  9.     };
  10.     block();
  11. }

//打印

  1. 2019-01-17 11:17:12.020409+0800 MJ_TEST[1304:76856] 30
  2. 2019-01-17 11:17:12.020869+0800 MJ_TEST[1304:76856] -[Person dealloc]
  3. Program ended with exit code: 0

//clang

  1. struct __Block_byref_blockPer_1 {
  2.   void *__isa;
  3. __Block_byref_blockPer_1 *__forwarding;
  4.  int __flags;
  5.  int __size;
  6.  void (*__Block_byref_id_object_copy)(void*, void*);
  7.  void (*__Block_byref_id_object_dispose)(void*);
  8.  Person *blockPer;
  9. };
  12. struct __test2_block_impl_0 {
  13.   struct __block_impl impl;
  14.   struct __test2_block_desc_0* Desc;
  15.   __Block_byref_blockPer_1 *blockPer; // by ref
  16.   __test2_block_impl_0(void *fp, struct __test2_block_desc_0 *desc, __Block_byref_blockPer_1 *_blockPer, int flags=0) : blockPer(_blockPer->__forwarding) {
  17.     impl.isa = &_NSConcreteStackBlock;
  18.     impl.Flags = flags;
  19.     impl.FuncPtr = fp;
  20.     Desc = desc;
  21.   }
  22. };
  25. static void __test2_block_copy_0(struct __test2_block_impl_0*dst, struct __test2_block_impl_0*src) {_Block_object_assign((void*)&dst->blockPer, (void*)src->blockPer, 8/*BLOCK_FIELD_IS_BYREF*/);}
  28. static void __test2_block_dispose_0(struct __test2_block_impl_0*src) {_Block_object_dispose((void*)src->blockPer, 8/*BLOCK_FIELD_IS_BYREF*/);}
  31. static struct __test2_block_desc_0 {
  32.   size_t reserved;
  33.   size_t Block_size;
  34.   void (*copy)(struct __test2_block_impl_0*, struct __test2_block_impl_0*);
  35.   void (*dispose)(struct __test2_block_impl_0*);
  36. }

分析：

<1>我们发现，__block修饰的blockPerl实例对象，系统也会自动生成一个新的对象__Block_byref_blockPer_1；被引用的类对象以指针的形式存在于该结构体中（Person *blockPer），该指针指向[[Person alloc] init]这个实例对象（位于堆区）；

<2>在__Block_byref_blockPer_1结构体中，还存在__Block_byref_id_object_copy和__Block_byref_id_object_dispose两个函数指针，分别指向__Block_byref_id_object_copy_131函数和__Block_byref_id_object_dispose_131函数（作用同上），如下：

  1. static void __Block_byref_id_object_copy_131(void *dst, void *src) {
  2.  _Block_object_assign((char*)dst + 40, *(void * *) ((char*)src + 40), 131);
  3. }
  4. static void __Block_byref_id_object_dispose_131(void *src) {
  5.  _Block_object_dispose(*(void * *) ((char*)src + 40), 131);
  6. }

很显然，这两个函数的作用也是针对某个对象的内存管理，那是哪个对象呢？

首先，_Block_object_assign和_Block_object_dispose的第三个参数为131，是指__block修饰实例对象的情形；

其次，dst是__Block_byref_blockPer_1对象的地址，加40是什么？我们算出Person *blockPer指针的地址偏移量正好为40（8+8+4+4+8+8，指针变量占8个字节），那么可以肯定，上述两个函数就是对Person *blockPer指向的实例对象[[Person alloc] init]的内存管理；

所以，我们可以推测出以下结构：block对象__test2_block_impl_0通过其内部成员变量blockPer持有__Block_byref_blockPer_1对象，而__Block_byref_blockPer_1对象又通过其内部成员变量blockPer持有[[Person alloc] init]实例对象；

我们知道，前者通过_test2_block_copy_0函数和__test2_block_dispose_0函数进行内存管理，其持有必定是强引用，，这点没问题；而后者的持有是通过__Block_byref_id_object_copy_131函数和__Block_byref_id_object_dispose_131函数进行内存管理，但其持有是强引用还是弱引用呢？往下看；

//__weak修饰

  1. __block __weak Person *blockPer = per;

//clang：xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc -fobjc-arc -fobjc-runtime=ios-9.0.0 main.m（注：要设置runtime，否则编译会报错）

  1. struct __Block_byref_blockPer_1 {
  2.   void *__isa;
  3. __Block_byref_blockPer_1 *__forwarding;
  4.  int __flags;
  5.  int __size;
  6.  void (*__Block_byref_id_object_copy)(void*, void*);
  7.  void (*__Block_byref_id_object_dispose)(void*);
  8.  Person *__weak blockPer;
  9. };

//打印

  1. 2019-01-17 12:17:20.776779+0800 MJ_TEST[1598:105742] 30
  2. 2019-01-17 12:17:20.777113+0800 MJ_TEST[1598:105742] -[Person dealloc]
  3. Program ended with exit code: 0

分析：

<1>我们发现，如果没有__weak修饰，blockPer格式为Person *blockPer，默认为strong类型；__weak修饰后，则会变成weak类型；

<2>根据之前的分析，其实__Block_byref_blockPer_1对象对[[Person alloc] init]实例对象的引用，取决于指向该实例对象的指针类型（因为对象引用是指针传递，前面已讲过）；

这里有个问题，为什么__weak修饰后，Person实例对象打印前没有被销毁呢？因为该实例对象的作用域在test2()函数体内，而block的回调也在函数体内，因此回调时，该实例对象并没有被销毁；

接下来，我们可以验证下： 

分析：此时，block回调前，Person实例对象就被销毁了，说明block对象对实例对象的引用取决于Person对象指针的引用类型；

我们再切换到MRC模式下看看：

//代码

  1. void test4()
  2. {
  3.     Person *per = [[Person alloc] init];
  4.     
  5.     MyBlock block = [^{
  6.         NSLog(@"%p", per);
  7.     } copy];
  8.     
  9.     [per release];
  10.     
  11.     block();
  12.     
  13.     [block release];
  14. }

//打印

  1. 2019-01-17 13:52:05.667590+0800 MJ_TEST[2106:151409] 0x10061add0
  2. 2019-01-17 13:52:05.668200+0800 MJ_TEST[2106:151409] -[Person dealloc]
  3. Program ended with exit code: 0

分析：当per指针象release时，[[Person alloc] init]实例对象并没有被释放，而当block指针release时，[[Person alloc] init]实例对象才被释放（block对象不再持有该实例对象），这也印证了上述的分析；

 

 

GitHub

原文链接：http://www.cnblogs.com/lybSkill/p/10278567.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

iOS热门文章

  • snapkit更新约束崩溃的问题
  • iOS 14 UDP收不到广播处理
  • iOS开发用如何用类&quot;SKStoreProductViewController&quot;跳转AppStore点赞评分？
  • Charles抓包iPhone注意点以及SSL Proxying enabled for this host
  • 笔记：long、longlong、int、float、NSString相互转换
  • ios开发UI篇—UITextfield
  • 自定义相机碰到的问题，比如常见的拍照录制视频方向，镜像左右颠倒等问题
  • C 和 Object-C中的 #ifdef #ifndef
  • 使用Hbuilder将自己app发布到App Store（一）
  • iOS开发 - 超级签名实现之描述文件

    • iOS推荐文章

  • iOS开发基础135-Core Data
  • uniapp-vue3-oadmin手机后台实例|vite5.x+uniapp多端仿ios管理系统
  • 苹果支付有哪些坑，为什么苹果支付比支付宝和微信容易丢单？
  • 带你走进灵动岛
  • vue3+ts Axios封装—重复请求拦截
  • axios详解以及完整封装方法
  • 关于 axios 是什么？以及怎么用？
  • iOS气泡提示工具BubblePopup的使用
  • 一篇文章带你详细了解axios的封装 - 公众号-web前端进阶
  • [MAUI]模仿iOS多任务切换卡片滑动的交互实现

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号