iOS Block捕获外部变量和ARC自动拷贝block-低调大师

iOS Block捕获外部变量和ARC自动拷贝block

2016-11-02 646

Block内引用外部变量的问题

#define BLog(prefix,obj) {NSLog(@"位置和指针变量名:%@ ,指针内存地址:%p, 指针值:%p ,指向的对象:%@ ",prefix,&obj,obj,obj);}

// 强引用
- (void)blockVariableStrongReferenceTest
{
    NSLog(@"\n");
    NSObject *obj = [[NSObject alloc] init];
    BLog(@"StrongRef obj",obj);
    void(^testBlock)()= ^(){
        BLog(@"StrongRef in block",obj);
    };
    testBlock();
    // Block外部尝试将obj置为nil
    obj = nil;
    testBlock();  // 第二次调用block
}

运行结果

 位置和指针变量名:StrongRef obj ,指针内存地址:0x7fff543d0c98, 指针值:0x7fcb1bd22390 ,指向的对象:<NSObject: 0x7fcb1bd22390> 

 位置和指针变量名:StrongRef in block ,指针内存地址:0x7fcb1c903fb0, 指针值:0x7fcb1bd22390 ,指向的对象:<NSObject: 0x7fcb1bd22390> 

 位置和指针变量名:StrongRef in block ,指针内存地址:0x7fcb1c903fb0, 指针值:0x7fcb1bd22390 ,指向的对象:<NSObject: 0x7fcb1bd22390

分析

方法内部的obj变量在栈中，变量内存地址0x7fff543d0c98，所指向的对象<NSObject: 0x7fcb1bd22390>在堆中，内存地址0x7fcb1bd22390，它的引用计数＋1。
Block中obj指针已经不是外部的obj指针了,它是外部变量obj的拷贝，它的内存地址是0x7fcb1c903fb0,跟外部obj不一样，但是所指向的对象也是0x7fcb1bd22390，0x7fcb1bd22390对象引用计数再＋1＝2。
block中的obj指针（内存地址是0x7fcb1c903fb0）对对象(<NSObject: 0x7fcb1bd22390>)的引用是强引用，在外部将obj（地址0x7fff543d0c98）置为nil后，外部的obj不再指向<NSObject: 0x7fcb1bd22390>对象，0x7fcb1bd22390对象的引用计数－1，引用计数为1，0x7fcb1bd22390对象内存不被自动回收，所以第二次调用block，0x7fcb1bd22390对象还在内存中。

结论
block内部的obj 指针是外部obj指针的拷贝，有2个指针指向同一个NSObject对象，但只将外部的obj指针置为nil,NSObject对象的引用计数不为0，无法回收。

// 弱引用
- (void)blockVariableWeakReferenceTest
{
    NSLog(@"\n");
    NSObject *obj = [[NSObject alloc] init];
    BLog(@"StrongRef obj",obj);  
    __weak NSObject *weakObj = obj;
    BLog(@"WeakRef weakObj", weakObj);
    void(^testBlock)()= ^(){
        BLog(@"weakObj in block",weakObj);
    };
    testBlock();
    obj = nil; 
    testBlock();
}

运行结果

 位置和指针变量名:StrongRef obj ,指针内存地址:0x7fff543d0c98, 指针值:0x7fcb1bd2fee0 ,指向的对象:<NSObject: 0x7fcb1bd2fee0> 

 位置和指针变量名:WeakRef weakObj ,指针内存地址:0x7fff543d0c90, 指针值:0x7fcb1bd2fee0 ,指向的对象:<NSObject: 0x7fcb1bd2fee0> 

位置和指针变量名:weakObj in block ,指针内存地址:0x7fcb1bc072b0, 指针值:0x7fcb1bd2fee0 ,指向的对象:<NSObject: 0x7fcb1bd2fee0> 

 位置和指针变量名:weakObj in block ,指针内存地址:0x7fcb1bc072b0, 指针值:0x0 ,指向的对象:(null) 
`

结论

分析：

方法内部的weakObj变量在栈中，变量内存地址0x7fff543d0c98，所指向的对象<NSObject: 0x7fcb1bd2fee0>在堆中，内存地址0x7fcb1bd2fee0，它的引用计数＋1。
weakObj变量也在栈中，内存为0x7fff543d0c90,所指向的对象也是<NSObject: 0x7fcb1bd2fee0>,弱引用，所以0x7fcb1bd2fee0对象的引用计数不增加，仍然为1.
Block中weakObj它的内存地址是0x7fcb1bc072b0，跟外部的weakObj不同，但是所指向的对象也是0x7fcb1bd2fee0，弱引用，0x7fcb1bd2fee0对象引用计数还是不增加，仍然是1。
-在外部将obj（地址0x7fff543d0c98）置为nil后，外部的obj不再指向<NSObject: 0x7fcb1bd2fee0>对象，0x7fcb1bd2fee0对象的引用计数－1，引用计数为0，ARC回收0x7fcb1bd2fee0对象内存，并将指向它的弱引用指针赋值为nil,所以第二次调用block，0x7fcb1bd2fee0对象不在在内存中。

Block生命周期内的对象安全

在block中__weak声明的指针去引用对象可以避免循环引用的问题，但是当外部对象被释放了，block 内部会访问不到这个对象. 这种问题如何解决呢？先来看一段代码：

//多线程时Block生命周期内对象安全
- (void)blockVariableMutiThreadTest
{
    NSObject *obj = [[NSObject alloc]init]; //obj强引用,<NSObject: 0x7f9413c1c040>对象引用计数＋1，＝1
    BLog(@"obj", obj);
    __weak NSObject *weakObj = obj;//weakObj弱引用,<NSObject: 0x7f9413c1c040>对象引用计数不变，＝1
    BLog(@"weakObj-0", weakObj);
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        __strong NSObject *strongObj = weakObj; //strongObj强引用,<NSObject: 0x7f9413c1c040>对象引用计数＋1，＝2
        sleep(3);
        BLog(@"weakObj - block", weakObj);
        BLog(@"strongObj - block", strongObj);
    });
    sleep(1);
    obj = nil; //obj被置为nil，<NSObject: 0x7f9413c1c040>对象引用计数－1，＝1
    BLog(@"weakObj-1", weakObj);  //没被释放
    sleep(4); //block在异步线程中执行完毕（在另一块内存中执行），block内存被释放，<NSObject: 0x7f9413c1c040>对象引用计数－1，＝0；ARC开始把0x7f9413c1c040对象内存回收，把弱引用weakObj置为nil
    BLog(@"weakObj-2", weakObj);
}

执行结果如下:

位置和指针变量名:obj ,指针内存地址:0x7fff51888c98, 指针值:0x7f9413c1c040 ,指向的对象:<NSObject: 0x7f9413c1c040> 
位置和指针变量名:weakObj-0 ,指针内存地址:0x7fff51888c90, 指针值:0x7f9413c1c040 ,指向的对象:<NSObject: 0x7f9413c1c040> 
位置和指针变量名:weakObj-1 ,指针内存地址:0x7fff51888c90, 指针值:0x7f9413c1c040 ,指向的对象:<NSObject: 0x7f9413c1c040> 
位置和指针变量名:weakObj - block ,指针内存地址:0x7f9413d9a880, 指针值:0x7f9413c1c040 ,指向的对象:<NSObject: 0x7f9413c1c040> 
位置和指针变量名:strongObj - block ,指针内存地址:0x1187e2e08, 指针值:0x7f9413c1c040 ,指向的对象:<NSObject: 0x7f9413c1c040> 
位置和指针变量名:weakObj-2 ,指针内存地址:0x7fff51888c90, 指针值:0x0 ,指向的对象:(null)

总结：
多线程的时候，在 block 外部用__weak声明的变量指向一个对象, 通过把weak声明的变量值赋值给block内部的```strong变量，实现在block内对该对象进行强引用，这样可以在block生命周期内保留该对象不被释放，在block生命周期结束后，对象内存被释放。

block修改外部变量 __block变量

- (void)blockVariable
{
   // 使用__block
   NSObject *obj = [[NSObject alloc]init];
   BLog(@"obj",obj); // 1 
   __block NSObject *blockObj = obj;
   obj = nil;
   BLog(@"外部blockObj -1",blockObj); // 2
   void(^testBlock)() = ^(){
       BLog(@"内部blockObj - block",blockObj); // 5
       NSObject *obj2 = [[NSObject alloc]init];
       BLog(@"内部obj2",obj2);   // 6
       blockObj = obj2;
       BLog(@"blockObj - block",blockObj); // 7
   };
   NSLog(@"%@",testBlock);   // 3

   BLog(@"外部blockObj -2",blockObj); // 4
   testBlock();
   BLog(@"外部blockObj -3",blockObj);   // 8

}

运行结果

 位置和指针变量名:obj ,指针内存地址:0x7fff5dd2ec78, 指针值:0x7fa082661a00 ,指向的对象:<NSObject: 0x7fa082661a00> 
 位置和指针变量名:外部blockObj -1 ,指针内存地址:0x7fff5dd2ec70, 指针值:0x7fa082661a00 ,指向的对象:<NSObject: 0x7fa082661a00>

 <__NSMallocBlock__: 0x7fa084906fa0>      ------ 这是block地址和类型

 位置和指针变量名:外部blockObj -2 ,指针内存地址:0x7fa084905838, 指针值:0x7fa082661a00 ,指向的对象:<NSObject: 0x7fa082661a00> 

 位置和指针变量名:内部blockObj - block ,指针内存地址:0x7fa084905838, 指针值:0x7fa082661a00 ,指向的对象:<NSObject: 0x7fa082661a00>        
 位置和指针变量名:内部obj2 ,指针内存地址:0x7fff5dd2eba8, 指针值:0x7fa084916660 ,指向的对象:<NSObject: 0x7fa084916660> 
 位置和指针变量名:blockObj - block ,指针内存地址:0x7fa084905838, 指针值:0x7fa084916660 ,指向的对象:<NSObject: 0x7fa084916660> 

 位置和指针变量名:外部blockObj -3 ,指针内存地址:0x7fa084905838, 指针值:0x7fa084916660 ,指向的对象:<NSObject: 0x7fa084916660>

分析：

第3处日志打印了一个testBlock对象，blockObj的地址发生变化。此时，block对象 从栈拷贝到堆上，__block变量blockObj，也被拷贝到堆上。block对象拥有blockObj指针指向的对象。注意：这是个强引用哦。
关注4到8 处日志，用__block关键字声明blockObj指针后，block内外的变量blockObj都是0x7fa084905838，也就是block内外的blockObj指针是同一个指针。
block内部改变 blockObj指针指向的对象，改动在 block外部可见。

关于 block访问外部变量原理

block实现原理(一)

block和变量的内存管理(二)

在oc，在block中直接访问外部变量，访问的是外部变量的copy。用clang后将 .m翻译为.cpp文件后发现，外部函数是通过传值方式将变量值传给block（block结构体、block最终要执行的函数代码）.
使用了__block后，外部函数是通过指针传递，将变量传递到 block 内，所以可以修改变量值.

Block在内存中的位置

Block作为C语言的扩展，并不是高新技术，和其他语言的闭包或lambda表达式是一回事。需要注意的是由于Objective-C在iOS中不支持GC机制，使用Block必须自己管理内存，而内存管理正是使用Block坑最多的地方，错误的内存管理要么导致return cycle内存泄漏要么内存被提前释放导致crash。 Block的使用很像函数指针，不过与函数最大的不同是：Block可以访问函数以外、词法作用域以内的外部变量的值。换句话说，Block不仅实现函数的功能，还能携带函数的执行环境。

可以这样理解，Block其实包含两个部分内容：

Block执行的代码，这是在编译的时候已经生成好的；
一个包含Block执行时需要的所有外部变量值的数据结构。 Block将使用到的、作用域附近的变量建立一份快照拷贝

根据Block在内存中的位置分为三种类型：_NSConcreteGlobalBlock，_NSConcreteMallocBlock, _NSConcreteStackBlock。
_NSConcreteGlobalBlock：类似函数，位于text段；
_NSConcreteStackBlock：位于栈内存，函数返回后Block将无效；
_NSConcreteMallocBlock：位于堆内存。

_NSConcreteGlobalBlock：

Blocks that don't capture any variables are global blocks. Since all instances of the block are the same, the compiler can just allocate one copy statically for the life of the program。

_NSConcreteStackBlock 和 _NSConcreteMallocBlock：

Blocks that capture variables (closures) are either stack or heap (malloc) blocks. Blocks start out on the stack, as stack blocks. When a stack block is copied for the first time, it is moved to the heap. Copying a heap block does not create another copy; but simply retains it.
在开启 ARC 时，大部分情况下编译器通常会将创建在栈上的 block 自动拷贝到堆上。

当 block 作为函数返回值返回时，编译器自动将 block 作为 _Block_copy 函数，效果等同于 block 直接调用 copy 方法；
当 block 被赋值给 __strong id 类型的对象或 block 的成员变量时，编译器自动将 block 作为 _Block_copy 函数，效果等同于 block 直接调用 copy 方法；
当 block 作为参数被传入方法名带有 usingBlock 的 Cocoa Framework 方法或 GCD 的 API 时。这些方法会在内部对传递进来的 block 调用 copy 或 _Block_copy 拷贝;

ARC中自动copy block的例子

 - (void)blockObjectInMemory
{
    // global block
    void (^globalBlockInMemory)(int number) = ^(int number){
        printf("%d \n",number);
    };
    globalBlockInMemory(90);
    BLog(@"global block %@", globalBlockInMemory);

    // malloc block
    int outVariable = 100;
    void (^mallocBlockInMemory)(int number) = ^(int number){
        printf("%d \n",outVariable+number);
    };
    BLog(@"stackBlock block %@", mallocBlockInMemory);     // ARC 自动将栈中block拷贝到堆上
}

 位置和指针变量名:global block %@ ,指针内存地址:0x7fff5b422c78, 指针值:0x1047e01f0 ,指向的对象:<__NSGlobalBlock__: 0x1047e01f0> 
 位置和指针变量名:stackBlock block %@ ,指针内存地址:0x7fff5b422c68, 指针值:0x7fe6849085f0 ,指向的对象:<__NSMallocBlock__: 0x7fe6849085f0>

- (id)returnBlock
{
    int outVariable = 100;
    void (^mallocBlockInMamory)(void) = ^(void){
            NSLog(@"in block");
    };
    BLog(@" block  ", mallocBlockInMamory);
    return mallocBlockInMamory;
}

- (void)blockInmemory
{
    id block = [self returnBlock];
    BLog(@"a block %@", block);
}

位置和指针变量名: block   ,指针内存地址:0x7fff516a9c30, 指针值:0x10e559250 ,指向的对象:<__NSGlobalBlock__: 0x10e559250> 
位置和指针变量名:a block %@ ,指针内存地址:0x7fff516a9c78, 指针值:0x10e559250 ,指向的对象:<__NSGlobalBlock__: 0x10e559250>

在没有ARC之前，由于ARC 自动将栈中block拷贝到堆上，所以当returnBlock函数退出，在栈中内存释放后，仍然可以访问到block对象。

ARC 中需要手动拷贝Block的例子

在以下情形中， block 会从栈拷贝到堆：

当 block 调用 copy 方法时，如果 block 在栈上，会被拷贝到堆上；
当 block 作为函数返回值返回时，编译器自动将 block 作为 _Block_copy 函数，效果等同于 block 直接调用 copy 方法；
当 block 被赋值给 __strong id 类型的对象或 block 的成员变量时，编译器自动将 block 作为 _Block_copy 函数，效果等同于 block 直接调用 copy 方法；
当 block 作为参数被传入方法名带有 usingBlock 的 Cocoa Framework 方法或 GCD 的 API 时。这些方法会在内部对传递进来的 block 调用 copy 或 _Block_copy 进行拷贝;

其他情况需要手动拷贝。

- (void)stackBlockInMemory
{
    NSArray *array = [self getBlockArray];
    id block = array[0];
    BLog(@"block %@", block);
}

- (id)getBlockArray
{
    int val = 10;
    return [[NSArray alloc] initWithObjects:
            ^{NSLog(@"value:%d", val);},
            ^{NSLog(@"value:%d", val);}, nil];
}

程序会报EXC_BAD_ACCESS ,getBlockArray返回的数组里面的 block 是不可访问的。

手动copy后，block拷贝到堆上，getBlockArray函数返回的栈帧被销毁后，仍可以访问堆中的block拷贝。

- (id)getBlockArray
{
    int val = 10;
    return [[NSArray alloc] initWithObjects:
            [^{NSLog(@"value:%d", val);} copy],
            [^{NSLog(@"value:%d", val);} copy], nil];
}

Block中造成内存泄漏的一些场景

Android应用框架之PackageManagerService

系统在启动的时候会启动一个叫做PackageManagerService的服务，顾名思义，这个服务主要管理安装在设备上的应用程序，其中最为重要的工作就是在在系统启动之后，PackageManagerService会扫描特定目录下地以apk为后缀的文件，然后将对应的应用安装到系统中。注意，这里的安装并不是我们平时所说的安装，它指的的是将存放在磁盘之上的静态应用程序文件进行解析，并将相关信息注册到系统中。而具体的解析工作实际就是读取应用的配置文件manifest.xml，并将文件中配置的组件（Activity,Service,BroadcastRecevier,ContentProvider），权限等信息注册到PackageManagerService中。本篇博客主要介绍PackageManagerService的启动过程，以及PackageManagerService如何安装各个应用程序。 1.PackageManagerService启动过程和ActivityManagerService，WindowManagerService一样，PackageManagerService是一...

2016-11-03

557

原文地址：http://android.xsoftlab.net/training/activity-testing/activity-basic-testing.html 为了验证在布局与功能上没有差池，很重要的一点就是需要为每个Activity创建对应的测试类。对每个测试类还需要创建单独的测试用例，这其中包含测试环境，测试条件以及对Activity测试的测试方法。实现这些便可以进行测试并获知结果。如果其中一项测试失败了，这便意味着在代码中可能存在潜在的问题。创建测试用例 Activity测试都以结构化的方式实现。要确保将所有的测试放在一个单独的包中，与被测试代码区别开来。依照惯例，测试包的包名应当由应用的包名+后缀”.tests”组成。在完成测试包的创建之后，添加一个Java类以用于测试。依照惯例，该类的名称应当由要测试的类的类名+后缀”Test”组成。在Eclipse中创建测试用例的步骤如下： a.在工程中新建一个包。 b.设置包名为< your_app_package_name>.tests(例如，com.example.android.testingfun....

2016-11-03

576

资源下载

更多资源

优质分享App

近一个月的开发和优化，本站点的第一个app全新上线。该app采用极致压缩，本体才4.36MB。系统里面做了大量数据访问、缓存优化。方便用户在手机上查看文章。后续会推出HarmonyOS的适配版本。

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。