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

说明：

<1>阅读本文，最好阅读之前的block文章加以理解；

<2>本文内容：三种block类型的copy情况（MRC）、是否深拷贝、错误copy；

 

一、MRC模式下，三种block类型的copy情况

//代码

  1. void test1()
  2. {
  3.     int age = 10;
  4.     
  5.     void(^block1)(void) = ^{
  6.         NSLog(@"-----");
  7.     };
  8.     
  9.     void(^block2)(void) = ^{
  10.         NSLog(@"-----%d", age);
  11.     };
  12.     
  13.     id block3 = [block2 copy];
  14.     
  15.     NSLog(@"%@ %@ %@", [block1 class], [block2 class], [block3 class]);
  16.     NSLog(@"%@ %@ %@", [[block1 copy] class], [[block2 copy] class], [[block3 copy] class]);
  17. }

//打印

  1. 2019-01-11 14:14:06.902974+0800 MJ_TEST[2183:154918] __NSGlobalBlock__ __NSStackBlock__ __NSMallocBlock__
  2. 2019-01-11 14:14:06.903260+0800 MJ_TEST[2183:154918] __NSGlobalBlock__ __NSMallocBlock__ __NSMallocBlock__
  3. Program ended with exit code: 0

分析：

<1>只有stack类型block实例对象copy后的类型变为malloc，这个前面文章已经讨论过，没有问题；

<2>global类型实例对象存储在数据区，copy操作其实什么也没做；malloc在堆区，copy之后肯定还是在堆区，但不会开辟新的内存，只是引用计数加1——此处分析，可以通过clang和地址、引用计数打印来查看，此处不再赘述；

结论： 

补充：上述copy的操作是针对block实例对象，那么类对象是存在哪个区呢？往下看

//代码

  1. int a = 20;
  3. void test2()
  4. {
  5.     int b = 10;
  6.     
  7.     void(^block1)(void) = ^{
  8.         NSLog(@"-----");
  9.     };
  10.     
  11.     void(^block2)(void) = ^{
  12.         NSLog(@"-----%d", b);
  13.     };
  14.     
  15.     id block3 = [block2 copy];
  16.     
  17.     id block1Cls = object_getClass(block1);
  18.     id block2Cls = object_getClass(block2);
  19.     id block3Cls = object_getClass(block3);
  20.     
  21.     NSLog(@"a--global--%p", &a);
  22.     NSLog(@"b--auto place--%p", &b);
  23.     NSLog(@"alloc----%p", [[NSObject alloc] init]);
  24.     NSLog(@"Person----%p", [Person class]);
  25.     
  26.     NSLog(@"------block---instance---");
  27.     NSLog(@"block1----%@ %p", [block1 class], block1);
  28.     NSLog(@"block2----%@ %p", [block2 class], block2);
  29.     NSLog(@"block3----%@ %p", [block3 class], block3);
  30.     
  31.     NSLog(@"------block---Class---");
  32.     NSLog(@"block1Cls----%@ %p", block1Cls, block1Cls);
  33.     NSLog(@"block2Cls----%@ %p", block2Cls, block2Cls);
  34.     NSLog(@"block3Cls----%@ %p", block3Cls, block3Cls);
  35. }

//打印

  1. 2019-01-11 14:58:29.922125+0800 MJ_TEST[2443:177646] a--global--0x100002520
  2. 2019-01-11 14:58:29.922498+0800 MJ_TEST[2443:177646] b--auto place--0x7ffeefbff59c
  3. 2019-01-11 14:58:29.922525+0800 MJ_TEST[2443:177646] alloc----0x100526420
  4. 2019-01-11 14:58:29.922561+0800 MJ_TEST[2443:177646] Person----0x1000024f8
  5. 2019-01-11 14:58:29.922585+0800 MJ_TEST[2443:177646] ------block---instance---
  6. 2019-01-11 14:58:29.922639+0800 MJ_TEST[2443:177646] block1----__NSGlobalBlock__ 0x1000020c0
  7. 2019-01-11 14:58:29.922666+0800 MJ_TEST[2443:177646] block2----__NSStackBlock__ 0x7ffeefbff560
  8. 2019-01-11 14:58:29.922699+0800 MJ_TEST[2443:177646] block3----__NSMallocBlock__ 0x102812000
  9. 2019-01-11 14:58:29.922717+0800 MJ_TEST[2443:177646] ------block---Class---
  10. 2019-01-11 14:58:29.922736+0800 MJ_TEST[2443:177646] block1Cls----__NSGlobalBlock__ 0x7fffb33c3460
  11. 2019-01-11 14:58:29.922756+0800 MJ_TEST[2443:177646] block2Cls----__NSStackBlock__ 0x7fffb33c3060
  12. 2019-01-11 14:58:29.922777+0800 MJ_TEST[2443:177646] block3Cls----__NSMallocBlock__ 0x7fffb33c3160
  13. Program ended with exit code: 0

分析：

<1>Person类对象：打印出的类对象Person的地址跟全局变量a和global类型block实例对象的地址类似度极高（都以"0x100002"开头），我们知道全局变量a和global类型block实例变量都是存放在数据区（全局区），那么可以肯定类对象也是存放在数据区中；

<2>block类对象：通过runtime的API我们拿到了三种类型block类对象，发现类对象的地址并不以"0x100002"开头———其中的原因我就懵逼了（内存地址不是很了解），但是可以推断应该也是在数据区，为什么呢？往下看

//代码

  1. typedef void(^Block)(void);
  2. Block block1;
  4. void test3()
  5. {
  6.     int b = 10;
  7.     
  8.     block1 = ^{
  9.         NSLog(@"-----%d", b);
  10.     };
  11.     
  12.     NSLog(@"%p %p", block1, object_getClass(block1));
  13.     
  14. }

//设置全局断点 

//打印

  1. 2019-01-11 16:34:06.281146+0800 MJ_TEST[3354:234187] 0x7ffeefbff538 0x7fffb33c3060
  2. 2019-01-11 16:34:06.281455+0800 MJ_TEST[3354:234187] ------272632520
  3. 2019-01-11 16:34:06.281477+0800 MJ_TEST[3354:234187] 0x7ffeefbff538 0xf9552b000e0
  4. 2019-01-11 16:34:06.281496+0800 MJ_TEST[3354:234187] 0x7ffeefbff588 0x7fffb33c3060

分析：

1）作为auto类型的局部变量，age的作用域仅限于test3()函数内，所以在main函数中再去回调block时，age已经被自动释放（所占内存被回收），所以age的值显示乱码；而同时block1其实也被销毁了，为什么？往下看

<1>object_getClass(block1)每次返回的值都不同，而其他只都保持不变（已经反复run了多次）；

<2>当我们第二次去回调block1时，如上报出一个很经典的错误——野指针调用，即指针所指向的内存空间已经被回收（即被释放），但是此时并没有对该指针赋值一个新的内存地址或者nil值，该指针变成了一个野指针，指向不明确；

补充：内存泄露：是指指针一直指向某一片内存空间，但是程序已经不需要再用该内存空间了，但其他的程序又无法调用该内存空间（只能开辟新的内存空间），这样很容易导致内存爆增；所以内存泄露跟野指针调用是完全相反的；

内存溢出：是指系统分配给程序的内存空间不够用，这样也很容易导致野指针调用的问题；

<3>对block1进行copy的情形：

//代码

  1. void test3()
  2. {
  3.     int b = 10;
  4.     
  5.     block1 = [^{
  6.         NSLog(@"-----%d", b);
  7.     } copy];
  8.     
  9.     NSLog(@"%p %p", block1, object_getClass(block1));
  10.     
  11. }
  15. int main(int argc, const char * argv[]) {
  16.     @autoreleasepool {
  17.         
  18. //        test1();
  19. //        test2();
  20.         test3();
  21.         block1();
  22.         NSLog(@"%p %p", block1, object_getClass(block1));
  23.         
  24.         int age = 10;
  25.         Block bl = ^{
  26.             NSLog(@"%d", age);
  27.         };
  28.         NSLog(@"%p %p", bl, object_getClass(bl));
  29.         block1();
  30.         block1();
  31.         block1();
  32.         
  33. //        test4();
  34. //        block();
  35.         
  36.     }
  37.     return 0;
  38. }

//打印

  1. 2019-01-11 16:40:36.144529+0800 MJ_TEST[3397:237736] 0x100526670 0x7fffb33c3160
  2. 2019-01-11 16:40:36.144849+0800 MJ_TEST[3397:237736] -----10
  3. 2019-01-11 16:40:36.144864+0800 MJ_TEST[3397:237736] 0x100526670 0x7fffb33c3160
  4. 2019-01-11 16:40:36.144893+0800 MJ_TEST[3397:237736] 0x7ffeefbff588 0x7fffb33c3060
  5. 2019-01-11 16:40:36.144916+0800 MJ_TEST[3397:237736] -----10
  6. 2019-01-11 16:40:36.144934+0800 MJ_TEST[3397:237736] -----10
  7. 2019-01-11 16:40:36.144950+0800 MJ_TEST[3397:237736] -----10
  8. Program ended with exit code: 0

分析：copy之后，block1一直没有被释放（堆区需要手动管理），即block1一直指向了合法的内存空间，因此不会出现野指针调用的bug；

综上：block1是一个指针变量，其指向等号右边的代码块本质是一个oc对象，存放在栈区中，当回调该代码块时，其已经被自动释放，但是block1因为没有重新赋值而变成了野指针，所以block1指向的代码块是已经被销毁了的；

2）block1销毁后，新创建的bl打印出的类对象的地址跟block1销毁前打印出的地址都是0x7fffb33c3060，因为类对象在内存中只有一份，据此，block1的类对象并没有随着block1的销毁而销毁，所以block的类对象不可能存在于栈区，同一个block类对象供所有创建的block实例对象的isa指针访问并且类对象是系统自动创建并管理的，因此也不可能存在于堆区，也不会存在于代码区

————结论：block类对象跟其他OC实例对象的类对象一样，都只存在于数据区！！！

 

二、block拷贝是否深拷贝

//代码

  1. void test4()
  2. {
  3.     int age = 10;
  4.     int *agePtr = &age;
  5.     NSLog(@"age---1:\n%d %p %d %p %p", age, &age, *agePtr, agePtr, &agePtr);
  6.     
  7.     block1 = [^{
  8.         NSLog(@"age----2:\n%d %p %d %p %p", age, &age, *agePtr, agePtr, &agePtr);
  9.     } copy];
  10.     
  11. }

//打印

  1. 2019-01-14 09:55:33.399468+0800 MJ_TEST[907:35484] age---1:
  2. 10 0x7ffeefbff59c 10 0x7ffeefbff59c 0x7ffeefbff590
  3. 2019-01-14 09:55:33.399735+0800 MJ_TEST[907:35484] age----2:
  4. 10 0x100400238 1 0x7ffeefbff59c 0x100400230
  5. Program ended with exit code: 0

分析：

<1>copy后，age、agePtr自身的地址值都发生了变化，说明两个变量都从栈区拷贝到了堆区；

<2>指针变量的值不再是10而是1（乱码），因为指针变量依然指向age拷贝前的内存区域，而该内存区随时可能被释放；

 

我们再看看对nsstring字符串的深拷贝（mutableCopy）和浅拷贝（copy）操作

//代码

  1. void test5()
  2. {
  3.     NSString *strSource = @"abc";
  4.     
  5.     NSLog(@"source:\n%@ %p %p", strSource, strSource, &strSource);
  6.     
  7.     NSString *str1 = [strSource copy];
  8.     
  9.     NSLog(@"str1:\n%@ %p %p", str1, str1, &str1);
  10.     
  11.     NSString *str2 = [strSource mutableCopy];
  12.     
  13.     NSLog(@"str2:\n%@ %p %p", str2, str2, &str2);
  14.     
  15. }

//打印

  1. 2019-01-14 10:14:26.299400+0800 MJ_TEST[1066:45457] source:
  2. abc 0x1000023a0 0x7ffeefbff598
  3. 2019-01-14 10:14:26.299783+0800 MJ_TEST[1066:45457] str1:
  4. abc 0x1000023a0 0x7ffeefbff590
  5. 2019-01-14 10:14:26.299897+0800 MJ_TEST[1066:45457] str2:
  6. abc 0x100507170 0x7ffeefbff588
  7. Program ended with exit code: 0

分析：

<1>很明显，浅拷贝只拷贝了指针变量str1（从代码区（常量区）到堆区），该指针依然指向代码区常量abc的内存区；

<2>深拷贝不仅指针变量被拷贝到堆区，而且常量abc也被拷贝到了堆区；

说明：深拷贝和浅拷贝区别，见参考链接：https://www.jianshu.com/p/63239d4d65e0；

 

综上所述：block的拷贝均拷贝了指针和该指针指向的值到堆区，但是新的指针却依然指向拷贝前的内存区域——因此，block的copy类似于深拷贝，不完全是深拷贝！

 

三、错误copy

//代码

  1. void(^block)(void);
  3. void test6()
  4. {
  5.     int age = 10;
  6.     NSLog(@"age----%p", &age);
  7.     
  8.     block = ^{
  9.         NSLog(@"age----%p", &age);
  10.         NSLog(@"----%d", age);
  11.     };
  12.     
  13.     
  14.     
  15.     NSLog(@"block--1---%p", block);
  16.     NSLog(@"block class--1---%p", [block class]);
  17.     id coBlock = [block copy];
  18.     NSLog(@"%@", [coBlock class]);
  19.     NSLog(@"block--2---%p", coBlock);
  20.     NSLog(@"block class--2---%p", [coBlock class]);
  21. }

//打印

  1. 2019-01-14 10:31:32.767665+0800 MJ_TEST[1159:53399] age----0x7ffeefbff59c
  2. 2019-01-14 10:31:32.767975+0800 MJ_TEST[1159:53399] block--1---0x7ffeefbff578
  3. 2019-01-14 10:31:32.768027+0800 MJ_TEST[1159:53399] block class--1---0x7fff8e0fe060
  4. 2019-01-14 10:31:32.768075+0800 MJ_TEST[1159:53399] __NSMallocBlock__
  5. 2019-01-14 10:31:32.768094+0800 MJ_TEST[1159:53399] block--2---0x100729380
  6. 2019-01-14 10:31:32.768111+0800 MJ_TEST[1159:53399] block class--2---0x7fff8e0fe160
  7. 2019-01-14 10:31:32.768127+0800 MJ_TEST[1159:53399] age----0x7ffeefbff598
  8. 2019-01-14 10:31:32.768141+0800 MJ_TEST[1159:53399] -----272632456
  9. Program ended with exit code: 0

分析：

<1>block：copy前后，block的地址发生了变化，因为block从栈区被拷贝到堆区了，这一点没问题；那么block的类对象地址也发生了变化，因为copy前block的类型为stack类型，之后是malloc类型（系统会自动创建一个类对象），前者存放在栈区，后者存放在堆区，所以也没问题；

<2>age：并没有被copy 到堆区，block回调时，已经被释放，其值为乱码，这点没问题；但是age的地址值这么发生变化了？我们再往下看

//代码

  1. void test7()
  2. {
  3.     int age = 10;
  4.     int *agePtr = &age;
  5.     NSLog(@"1----\n%d %p %d %p %p", age, &age, *agePtr, agePtr, &agePtr);
  6.     
  7.     block = ^{
  8.         NSLog(@"1----\n%d %p %d %p %p", age, &age, *agePtr, agePtr, &agePtr);
  9.     };
  10.     
  11.     id coBlock = [block copy];
  12. }

//打印

  1. 2019-01-14 10:54:30.119695+0800 MJ_TEST[1281:64385] 1----
  2. 10 0x7ffeefbff59c 10 0x7ffeefbff59c 0x7ffeefbff590
  3. 2019-01-14 10:54:30.119992+0800 MJ_TEST[1281:64385] 1----
  4. 10 0x7ffeefbff588 32766 0x7ffeefbff59c 0x7ffeefbff580
  5. Program ended with exit code: 0

分析：

<1>不论是age还是agePtr，block回调时，本身的地址都会发生变化，因为所占内存都被释放，内存地址不回固定，系统会重新编排（个人YY，具体不清楚）；

<2>但是，尽管age的值变成乱码，而指针变量agePtr的值却没变依然是原age的地址值——为什么指针变量的内存值不是乱码呢？也许是因为代码区（常量区）跟栈区、堆区的存储规则的区别，指针变量本身已经被释放，其值变与不变好像没有多大的意义——但是，从代码规范角度，被释放后，应当将指针变量置为nil，防止野指针调用！

结论：所谓错误的copy只是copy了block指针变量（等号左边），并非block代码块本身（等号右边）——因此，被引用的外部auto类型的局部变量不会被copy到堆区；

 

GitHub

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

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号