栈块、堆块、全局块

编译器版本为Clang5，主要技术是ARC，参考来自Objective-C Automatic Reference Counting (ARC)

block根据分配的内存位置分为栈块，堆块，全局块。

一个block在创建的时候，就可以确定其类型，判断一个block是那种类型其实很简单，规则如下(MRC和ARC都适用)：

1.如果一个block中引用了全局变量，或者没有引用任何外部变量(属性、实例变量、局部变量)，那么该block为全局块。
2.其它引用情况(局部变量，实例变量，属性)为栈块。

上面的规则中并不存在堆块的判断，因为以上规则的前提条件是：block在创建的时候，不是创建完之后赋值给变量，代码如下：

@interface MGBlockExample()
//属性
@property(nonatomic,assign)int a;

@end
@implementation MGBlockExample{
    int _b; //实例变量
}
//全局变量
int c = 3;

- (void)test{
    
    /*****      全局块        *****/
    
    //引用全局变量
    NSLog(@"aBlock:%@", ^{ NSLog(@"c:%d",c); }); //aBlock:__NSGlobalBlock__
    
    //没有引用变量
    NSLog(@"bBlock:%@", ^{ NSLog(@""); }); //bBlock:__NSGlobalBlock__
    
    
    /*****       栈块        *****/
    
    int d = 4;
    //不给赋值，但引用了局部变量
    NSLog(@"cBlock:%@",^void{ NSLog(@"d:%d",d); }); //cBlock:__NSStackBlock__
    //不给赋值，但引用了实例变量
    NSLog(@"dBlock:%@",^void{ NSLog(@"_b:%d",_b); }); //dBlock:__NSStackBlock__
    //不给赋值，但引用了属性
    NSLog(@"eBlock:%@",^void{ NSLog(@"self.a:%d",self.a); }); //eBlock:__NSStackBlock__
}
@end

全局块和栈块已经有规则可以判断，并且适用于MRC和ARC，规则的前提条件是block创建的时候。那么在将创建完的块之后赋值给变量会出现什么情况呢？看下面代码：

- (void)test1{
    //局部变量
    void (^fBlock)() = ^(){
        NSLog(@"d:%d",d);
    };
    
    //实例变量
    void (^gBlock)() = ^(){
        NSLog(@"_b:%d",_b);
    };
    
    //属性
    void (^hBlock)() = ^(){
        NSLog(@"self.a:%d",self.a);
    };
    NSLog(@"fBlock:%@", fBlock); 
    NSLog(@"gBlock:%@", gBlock); 
    NSLog(@"hBlock:%@", hBlock); 
    //MRC：上面操作输出//XBlock:__NSStackBlock__
    //ARC：上面操作输出//XBlock: __NSMallocBlock__
}

从上面代码可以看到在MRC环境中，block引用局部变量、实例变量、属性的的结果依然是生成栈块。而在ARC环境中，生成的是堆块。原因如下：

block是retainable object pointer类型。

在ARC环境中，ARC会对retainable type进行内存管理：

If an object is declared with retainable object owner type, but without an explicit ownership qualifier, its type is implicitly adjusted to have __strong qualification.
如果一个被定义对象是retainable object owner类型，并且没有明确指定内存管理策略，那么编译器会默认为其添加__strong修饰词。

所以上面的fBlock在ARC环境中是这样的：

__strong void (^fBlock)() = ^(){
        NSLog(@"d:%d",d);
    };

然后document又说：

With the exception of retains done as part of initializing a __strong parameter variable or reading a __weak variable, whenever these semantics call for retaining a value of block-pointer type, it has the effect of a Block_copy. The optimizer may remove such copies when it sees that the result is used only as an argument to a call.
对于block来说，不管是在创建对象的时候strong修饰还是在读取weak修饰的变量，其效果和用Block_copy修饰是一样的。当编译器觉得可以优化的时候就不会执行Block_copy函数，例如一个block初始化完之后就被当做一个参数使用了(例如cBlock、dBlock、eBlock)

所以上面fBlock的代码转成MRC是类似这样的：

void (^fBlock)() = [^(){
        NSLog(@"d:%d",d);
    } copy];

给block对象的-copy方法发送消息，会将该对象拷贝一份放入堆中，所以这个时候块从栈块变成堆块。

补充一下block的内存管理

不管是对block进行retian、copy、release,block的引用计数都不会增加，始终为1。

NSGlobalBlock:使用retain、copy、release都无效，block依旧存在全局区，且没有释放, 使用copy和retian只是返回block的指针。

NSStackBlock:使用retain、release操作无效；栈区block会在方法返回后将block空间回收； 使用copy将栈区block复制到堆区，可以长久保留block的空间，以供后面的程序使用。

NSMallocBlock:支持retian、release，虽然block的引用计数始终为1，但内存中还是会对引用进行管理，使用retain引用+1， release引用-1； 对于NSMallocBlock使用copy之后不会产生新的block，只是增加了一次引用，类似于使用retian。

总结起来是这样的：

1.在创建block的时候(MRC和ARC通用):

1.1. 如果一个block中引用了全局变量，或者没有引用任何外部变量(属性、实例变量、局部变量)，那么该block为全局块。
1.2. 其它引用情况(局部变量，实例变量，属性)为栈块。

2.在将block对象赋值给其它对象^(oBlock)()的时候(ARC):

2.1. 如果block是栈块，那么oBlock变成堆块(因为Clang编译器帮我们往block发送了copy消息)。
2.2. 如果block是全局块，那么oBlock也是全局块，如果block是堆块，那么oBlock也是堆块。

3.在将block对象赋值给其它对象^(oBlock)()的时候(MRC):

3.1. block是什么，oBlock便是什么。