经过__block的做用深刻研究block

block普通引用

默认状况下，在block中访问外部变量是经过复制一个变量来操做的，既能够读，可是写操做不对原变量生效，下面经过代码来举证

NSString *a = @"testa";
    NSLog(@"block前,a在堆中的地址%p,a在栈中的地址%p",a,&a);
    void(^testBlock)(void) = ^(void){
        NSLog(@"block内,a在堆中的地址%p,a在栈中的地址%p",a,&a);
    };
    NSLog(@"block后,a在堆中的地址%p,a在栈中的地址%p",a,&a);
    testBlock();

能够看出变量在堆中的地址实际上是一直不变的，在栈中的地址，在block外是不变的，block内从新开辟了一个空间来存放。
那么来计算下两个地址变化
block前,a指向堆中的地址0x1000ec0b0,a在栈中的地址0x16fd19f58
block后,a指向堆中的地址0x1000ec0b0,a在栈中的地址0x16fd19f58
block内,a指向堆中的地址0x1000ec0b0,a在栈中的地址0x17404e0c0
十六进制的0x16fd19f5八、0x17404e0c0转换为十进制数为，617097608八、6241444032。二者相差5546832956字节，再转换为MB为5289.8mb。已知 IOS中一个进程的栈区内存只有1M，Mac也只有8M(等有空找官方文档求证下),又由于堆地址要小于栈地址，因此在block内调用变量，在不使用__block的状况下，是在堆中新建了一个变量地址指向原变量，block做用域结束则销毁，不影响原变量。

 

咱们都知道：Block不容许修改外部变量的值，这里所说的外部变量的值，指的是栈中指针的内存地址。在block内调用变量，在不使用__block的状况下，是在堆中新建了一个变量地址指向原变量，block做用域结束则销毁，不影响原变量。

__block关键字

由前所知，经过__block修饰，block内部不只仅能够对外部变量进行读操做，也能够进行写操做了，那这是为何呢？一样用代码研究二者区别

__block NSString *a = @"testa";
    NSLog(@"block前,a指向堆中的地址%p,a在栈中的地址%p",a,&a);
    void(^testBlock)(void) = ^(void){
        NSLog(@"block内,a指向堆中的地址%p,a在栈中的地址%p",a,&a);
    };
    testBlock();
    NSLog(@"block后,a指向堆中的地址%p,a在栈中的地址%p",a,&a);

去掉时间戳后，打印的结果是

block前,a指向堆中的地址0x10007c0d0,a在栈中的地址0x16fd89f58
block内,a指向堆中的地址0x10007c0d0,a在栈中的地址0x1740533a8
block后,a指向堆中的地址0x10007c0d0,a在栈中的地址0x1740533a8

 

根据内存地址变化可见，__block所起到的做用就是只要观察到该变量被 block 所持有，就将“外部变量”在栈中的内存地址放到了堆中。进而在block内部也能够修改外部变量的值。原先地址是否直接抛弃不用再继续研究

Block不容许修改外部变量的值,Apple这样设计，应该是考虑到了block的特殊性，block也属于“函数”的范畴，变量进入block，实际就是已经改变了做用域。在几个做用域之间进行切换时，若是不加上这样的限制，变量的可维护性将大大下降。又好比我想在block内声明了一个与外部同名的变量，此时是容许呢仍是不容许呢？只有加上了这样的限制，这样的情景才能实现。

编译器作了什么？

通常使用的话，到这个程度已经足够了。咱们已经知道了加上__block关键字以后，编译器经过将外部变量同block一块儿copy到了堆区，而且将“外部变量”在栈中的内存地址改成了堆中的新地址。
若是多问一个为何？编译器是怎么作到这样的呢？咱们经过clang将 OC 代码转换为 C++ 文件：

clang -rewrite-objc 源代码文件名

转译的时候遇到了几个问题：

#import <UIKit/UIKit.h> ** ^** 1 error generated. 

经过Objective-C编译成C++代码报错文中的方式能够转译，可是又出现了新的问题;
2.clang: warning: using sysroot for 'iPhoneSimulator' but targeting 'MacOSX'
这个问题没能解决，而后换了个思路转译，
新代码以下

//坑爹的是NSLog都不能使用,否则会报NSLog错误。说白了仍是工具不熟悉，为何会出现这个状况都不清楚。有机会再看吧
int main() {
        int  a = 1;
        void(^testBlock)(void) = ^(void){
            
        };
        testBlock();
    
        __block int b = 2;
        void(^testBlockb)(void) = ^(void){
            b = 3;
        };
        testBlockb();
        return 0;
}

转译后代码以下

int main() {
        int a = 1;

        void(*testBlock)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
        ((void (*)(__block_impl *))((__block_impl *)testBlock)->FuncPtr)((__block_impl *)testBlock);





    __attribute__((__blocks__(byref))) __Block_byref_b_0 b = {(void*)0,(__Block_byref_b_0 *)&b, 0, sizeof(__Block_byref_b_0), 2};

        void(*testBlockb)(void) = ((void (*)())&__main_block_impl_1((void *)__main_block_func_1, &__main_block_desc_1_DATA, (__Block_byref_b_0 *)&b, 570425344));
        ((void (*)(__block_impl *))((__block_impl *)testBlockb)->FuncPtr)((__block_impl *)testBlockb);

        return 0;
}

代码变的很长很长，咱们的目的是研究__block加上去以后编译器的操做，精简下就是

//加__block前的声明变量是这样的
int a = 1;
//加__block后的声明变量是这样的
__attribute__((__blocks__(byref))) __Block_byref_b_0 b = {
  (void*)0,
  (__Block_byref_b_0 *)&b, 
  0,
   sizeof(__Block_byref_b_0), 
  2};

能够看到增长了__block修饰以后，编译器作了很多工做，修饰词中有__Block_byref_b_0重复出现，这是一个与block同样的结构体类型的自动变量实例！！！！
此时咱们在block内部访问val变量则须要经过一个叫__forwarding的成员变量来间接访问val变量。
讲__forwarding以前，须要先讨论一下block的存储域及copy操做。

1.Block的存储域及copy操做

前面提到，block内部的做用域是在堆上的，而且调用变量时会将变量copy到堆上，那么block自己是存储在堆上仍是栈上呢？
咱们先来看看一个由C/C++/OBJC编译的程序占用内存分布的结构：

实际上，block有三种类型，

• 全局块(_NSConcreteGlobalBlock)
• 栈块(_NSConcreteStackBlock)

• 堆块(_NSConcreteMallocBlock)
  这三种block各自的存储域以下图：

• 简而言之，存储在栈中的Block就是栈块、存储在堆中的就是堆块、既不在栈中也不在堆中的块就是全局块。（这听起来彷佛与文章上半部分的说明有冲突呢？其实并否则）

那么，咱们如何判断这个block的存储位置呢？
（1）Block不访问外界变量（包括栈中和堆中的变量）
Block 既不在栈又不在堆中，在代码段中，ARC和MRC下都是如此。此时为全局块。(_NSConcreteGlobalBlock)
（2）Block访问外界变量
MRC 环境下：访问外界变量的 Block 默认存储栈中。
ARC 环境下：访问外界变量的 Block 默认存储在堆中（实际是放在栈区，而后ARC状况下自动又拷贝到堆区），自动释放。

ARC下，访问外界变量的 Block为何要自动从栈区拷贝到堆区呢？
栈上的Block，若是其所属的变量做用域结束，该Block就被废弃，如同通常的自动变量。固然，Block中的__block变量也同时被废弃。以下图：

为了解决栈块在其变量做用域结束以后被废弃（释放）的问题，咱们须要把Block复制到堆中，延长其生命周期。开启ARC时，大多数状况下编译器会恰当地进行判断是否有须要将Block从栈复制到堆，若是有，自动生成将Block从栈上复制到堆上的代码。Block的复制操做执行的是copy实例方法。Block只要调用了copy方法，栈块就会变成堆块。
以下图：

在非ARC状况下则须要开发者调用copy方法手动复制，因为开发中几乎都是ARC模式，因此手动复制内容再也不过多研究。
将Block从栈上复制到堆上至关消耗CPU，因此当Block设置在栈上也可以使用时，就不要复制了，由于此时的复制只是在浪费CPU资源。
Block的复制操做执行的是copy实例方法。不一样类型的Block使用copy方法的效果以下表：

根据表得知，Block在堆中copy会形成引用计数增长，这与其余Objective-C对象是同样的。虽然Block在栈中也是以对象的身份存在，可是栈块没有引用计数，由于不须要，咱们都知道栈区的内存由编译器自动分配释放。
无论Block存储域在何处，用copy方法复制都不会引发任何问题。在不肯定时调用copy方法便可。

在ARC有效时，屡次调用copy方法彻底没有问题：

blk = [[[[blk copy] copy] copy] copy];
// 通过屡次复制，变量blk仍然持有Block的强引用，该Block不会被废弃。

2.__block变量与__forwarding

在copy操做以后，既然__block变量也被copy到堆上去了, 那么访问该变量是访问栈上的仍是堆上的呢?__forwarding 终于要闪亮登场了，以下图：

经过__forwarding, 不管是在block中仍是 block外访问__block变量, 也无论该变量在栈上或堆上, 都能顺利地访问同一个__block变量。
值得注意的是，在ARC下，使用 __block 也有可能带来的循环引用，

本文非原创，仅用来学习总结记录用,参考文章：
1.iOS中__block 关键字的底层实现原理
2.iOS Block详解
3.Objective-C中的Block