天天看点
返回

Block笔记（4）—— Block的类型

Block系列文章—————————————

Block笔记（1）—— 基本认识

Block笔记（2）—— 底层结构

Block笔记（3）—— 基础类型的变量捕获

Block笔记（4）—— Block的类型

Block笔记（5）—— 对象类型的auto变量捕获

Block笔记（6）—— __block的深入分析

————————————————————

前面的章节里面，我们了解到Block也是一个OC对象，因为它的底层结构中也有

isa

指针。例如下面这个

block

：

#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        //Block的定义
        void (^block)(void) = ^(){
            NSLog(@"Hello World");
        };
        
        NSLog(@"%@", [block class]);
        NSLog(@"%@", [block superclass]);
        NSLog(@"%@", [[block superclass] superclass]);
        NSLog(@"%@", [[[block superclass] superclass] superclass]);
    }
    return 0;
}
*********************** 运行结果 **************************
2019-06-05 14:44:53.179548+0800 Interview03-block[16670:1570945] __NSGlobalBlock__
2019-06-05 14:44:53.179745+0800 Interview03-block[16670:1570945] __NSGlobalBlock
2019-06-05 14:44:53.179757+0800 Interview03-block[16670:1570945] NSBlock
2019-06-05 14:44:53.179767+0800 Interview03-block[16670:1570945] NSObject
Program ended with exit code: 0

上面的代码中，我们通过

[xxx class]

和

[xxx supperclass]

方法，打印出

block

的类型以及父类的类型，可以看继承关系是这样的

__NSGlobalBlock__

->

__NSGlobalBlock

->

NSBlock

->

NSObject

这也可以很好地证明block是一个对象，因为它的基类就是

NSObject

。而且我们也就知道了，block中的

isa

成员变量肯定是从

NSObject

继承而来的。

它的编译后形式如下

Block笔记（4）—— Block的类型

图中的信息表明，该block的

isa

指向的class为

_NSConcreteStackBlock

。

奇怪，难道这里

isa

指向的

class

不应该和程序运行时打印出来的

class

一致吗？

这里补充一个细节：目前来说，LLVM编译器生成的中间文件不再是C++ 形式了，而我们在命令行里面，实际上是通过clang生成的C++ 文件，在语法细节上这两者是有差别的，但是大部分的逻辑和原理还是相近的，所以通过clang生成的C++ 中间代码，仅供我们作为参考，最终还是必须以运行时的结果为准，因为Runtime还是会在程序运行的时候，对之前编译过后的中间码进行一定的处理和调整的。

Block的类型

Block有3种类型

Block笔记（4）—— Block的类型

下面我们来一一解析，首先我们在回顾一下程序的内存布局

  • 代码段 占用空间很小，一般存放在内存的低地址空间，我们平时编写的所有代码，就是放在这个区域
  • 数据段 用来存放全局变量
  • 堆区 是动态分配内存的，用来存放我们代码中通过

    alloc

     生成的对象，动态分配内存的特点是需要程序员申请内存和管理内存。例如OC中

    alloc

     生成的对象需要调用

    releas

     方法释放【MRC下】，C中通过

    malloc

     生成的对象必须要通过

    free()

     去释放。
  • 栈区 系统自动分配和销毁内存，用于存放函数内生成的局部变量

下面借助一个经典的图例，来看一看不同类型的block到底存储在哪里！

Block笔记（4）—— Block的类型
(1) NSGlobalBlock(也就是_NSConcreteGlobalBlock)
如果一个block内部没有使用/访问自动变量(auto变量)，那么它的类型即为

__NSGlobalBlock__

 ，它会被存储在应用程序的 数据段

我们用代码来验证一下

Block笔记（4）—— Block的类型
Block笔记（4）—— Block的类型
Block笔记（4）—— Block的类型

以上三个图，展示了 除了

auto

变量外的其他几种变量被

block

访问的情况，打印的结果都是如下

2019-06-05 16:38:31.885797+0800 Interview03-block[17590:1712446] __NSGlobalBlock__
Program ended with exit code: 0

结果显示block的类型都是

__NSGlobalBlock__

。其实这种类型的block没有太多的应用场景，所以出镜率的很少，这里仅作了解就行。

(2) NSStaticBlock(也就是_NSConcreteStaticBlock)
如果一个block有使用/访问 自动变量(auto变量) ，那么它的类型即为

__NSStaticBlock__

 ，它会被存储在应用程序的 栈区

我们继续验证一波，之前代码调整如下

Block笔记（4）—— Block的类型

打印结果如下

2019-06-05 16:45:25.990687+0800 Interview03-block[17648:1721701] __NSMallocBlock__
Program ended with exit code: 0

咦？怎么这里的结果是

__NSMallocBlock__

？不应该是

__NSStaticBlock__

吗？原因在于当前处于ARC环境下，ARC机制已经为我们做过了一些处理，为了看清本质，我们先关掉ARC

Block笔记（4）—— Block的类型

再跑一边代码，输出结果如下

2019-06-05 16:52:08.500787+0800 Interview03-block[17712:1730384] __NSStackBlock__
Program ended with exit code: 0

好，我们看到，再没有ARC的帮助下，这里的block类型确实是

__NSStackBlock__

。

其实我们在很多场景下，都会用到这种类型的block，因为很多情况下，我们都会在block 中用到环境变量，而大部分的环境变量都可能是auto变量，思考一下，如果我们不做任何处理，会碰到什么麻烦吗？（?提醒：结合栈区内容的生命周期）

我们再将生面的代码调整如下

#import <Foundation/Foundation.h>

void (^block)(void);//全局变量block

void test(){
    int a = 10;
    
    block =     ^(){
                    NSLog(@"a的值为---%d",a);
                };
    
}

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        test();
        block();
    }
    return 0;
}

根据以上的代码，你的预期打印结果是多少呢，a的值10能被正确打印出来吗？看运行结果

2019-06-05 17:04:25.915160+0800 Interview03-block[17820:1746272] a的值为----272632584
Program ended with exit code: 0

瞧，

a

现在的值为

272632584

,很显然，这样的值用在我们的程序里面，肯定就破坏了我们原有的设计思路了。

那么就来分析一下：

  • 代码中，

    block

     是一个定义在函数外的全局变量
  • 在函数

    test()

     内，代码

    ^(){ NSLog(@"a的值为---%d",a); };

     首先会为我们生成一个

    __NSStaticBlock__

     类型的Block，它存储与当前函数

    test()

     的栈空间内，然后它的指针被赋值给了全局变量

    block

     。
  • 在

    main

     函数中，首先调用函数

    test()

     ，全局变量

    block

     就指向了

    test()

     函数栈上的这个

    __NSStaticBlock__

     类型的Block，然后

    test()

     调用结束，栈空间回收
  • 然后

    block

     被调用，问题就出在这里，此时，

    test()

     的栈空间都被系统回收去做其他事情了，也就是说上面的那个

    __NSStaticBlock__

     类型的Block的内存也被回收了。虽然通过

    对象block

     （或者说

    block指针

     ）,最终还可访问原来变量

    a

     的所指向的那块内存，但是这里面寸的值就无法保证是我们所需要的

    10

     了，所以可以看到打印结果是一个无法预期的数字。
❓❓那么该怎么解决这个问题呢？很自然的，我们就会想到，需要将那个

__NSStaticBlock__

 类型的Block转移到堆区上面去，这样它不会随着函数栈区的回收而被销毁，而可以由程序员在使用完它之后再去销毁它。
(3) NSMallocBlock(也就是_NSConcreteMallocBlock)
对

__NSStaticBlock__

 调用

copy

 方法，就可以转变成

__NSMallocBlock__

 ，它会被存储在堆区上

把上面的代码调整如下

#import <Foundation/Foundation.h>

void (^block)(void);//全局变量block

void test(){
    int a = 10;
    
    block =     [^(){ NSLog(@"a的值为---%d",a); } copy];
}

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        test();
        block();
        NSLog(@"block的类型为%@",[block class]);
    }
    return 0;
}

在给

block

赋值前，先进行

copy

操作，得到如下打印结果

2019-06-05 17:44:16.940492+0800 Interview03-block[18166:1799723] a的值为---10
2019-06-05 17:44:16.940752+0800 Interview03-block[18166:1799723] block的类型为__NSMallocBlock__
Program ended with exit code: 0

可以看到， 变量

a

的打印值还是

10

，并且

block

所指向的也确实是一个

__NSMallocBlock__

。正是由于

copy

之后，

[^(){ NSLog(@"a的值为---%d",a); } copy];

所返回的Block是存放在堆上的，所以里面

a

的值仍是被捕获时后的值

10

，因此打印结果不受影响。

你或许会好奇，如果对

__NSGlobalBlock__

 调用

copy

 方法呢？这里就直接告诉你，结果仍然是一个

__NSGlobalBlock__

 ，有兴趣可以自行代码走一波，这里不再赘述。
总结
Block笔记（4）—— Block的类型

对每一种类型的block调用copy后的结果如下

Block笔记（4）—— Block的类型

ARC环境下Block的copy问题

上面的篇幅，我们都是基于MRC环境下，对block在内存中的存储情况进行讨论。由于我们在平时代码中生成的block都是在函数内创建的，也就是都是

__NSStaticBlock__

类型的，而通常我们需要将其保存下来，在将来的某个时候调用，但是那个时间点上往往该block所在的函数栈已经不存在了，因此在MRC环境下，我们需要通过对其调用

copy

方法，将

__NSStaticBlock__

的内容复制到堆区内存上，使之成为一个

__NSMallocBlock__

，这样才不影响后续的使用，同时，作为使用者，需要确保在使用完block之后而不在需要它的时候，对其调用

release

方法将其释放掉，这样才能避免产生内存泄漏问题。

ARC的出现，为我们开发者做了很多繁琐而细致的工作，是我们不用再内存管理方面耗费太多精力，其中，就包括了对block的

copy

处理。举个例子，我们对上一份代码微调一下，把

copy

操作去掉，如下

#import <Foundation/Foundation.h>

void (^block)(void);//全局变量block

void test(){
    int a = 10;
    
    block =     ^(){ NSLog(@"a的值为---%d",a);   };
}

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        test();
        block();
        NSLog(@"block的类型为%@",[block class]);
    }
    return 0;
}

将ARC开关打开，运行程序我们得到如下结果

2019-06-05 20:29:31.503282+0800 Interview03-block[19472:1922021] ************10
2019-06-05 20:29:31.503652+0800 Interview03-block[19472:1922021] block的类型为__NSMallocBlock__
Program ended with exit code: 0

可以看到，这跟我们在MRC下手动将

block

进行

copy

之后的结果一样，说明ARC其实替我们做了相应的

copy

操作。

在ARC环境下，编译器会根据情况自动将栈上的block复制到堆上，例如以下的情况
  • block作为函数参数返回的时候
  • 将block复制给

    __strong

     指针的时候
  • block作为Cocoa API中方法名里面含有

    usingBlock

     的方法参数时
  • block作为GCD API的方法参数的时候
小细节–Block属性的书写方法
  • MRC下Block 属性的书写建议

@property (nonatomic, copy) void(^block)(void);
  • ARC下Block 属性的书写建议

@property (nonatomic, copy) void(^block)(void);

 //推荐

@property (nonatomic, strong) void(^block)(void);

 ARC下关键字

copy

 和

strong

 对

block属性

 的作用是一样的，因为

__strong

 指针指向

bloc

 k的时候，ARC会自动对

block

 进行copy操作，但是为了保持代码的一致性，建议还是使用

copy

 关键字来修饰。
Block系列文章—————————————

Block笔记（1）—— 基本认识

Block笔记（2）—— 底层结构

Block笔记（3）—— 基础类型的变量捕获

Block笔记（4）—— Block的类型

Block笔记（5）—— 对象类型的auto变量捕获

Block笔记（6）—— __block的深入分析

————————————————————
iOS - OC底层原理深入 block iOS objective-c 底层原理
上一篇: IP寻址和子网划分了解IP地址了解子网划分练习1练习2VLSM 可变长度子网掩码
下一篇: Block总结

继续阅读