Block在内存中的三种位置

首先，在 MRC 下，Block 默认是分配在栈上的，除非进行显式的 copy，但是在ARC的中，一般都是分配在堆中。

@interface SecondViewController ()
typedef void (^blk)(void);
@end

@implementation SecondViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view.
    __block int val = 1;

    //block保存在堆区
    __strong blk heapBlock = ^{
        val = 2;
    };
    NSLog(@"heapBlock: %@", heapBlock);

    //block保存在栈区
    __weak blk stackBlock = ^{
        val = 2;
    };
    NSLog(@"stackBlock: %@", stackBlock);
    
    //block保存在全局区
    blk globalBlock = ^{
    };
    NSLog(@"globalBlock: %@", globalBlock);
}

Log输出

2018-04-09 15:50:14.351940+0800 TestMRC[29483:4870456] heapBlock: <__NSMallocBlock__: 0x60000024c090>
2018-04-09 15:50:14.352184+0800 TestMRC[29483:4870456] stackBlock: <__NSStackBlock__: 0x7ffee57543d0>
2018-04-09 15:50:14.352318+0800 TestMRC[29483:4870456] globalBlock: <__NSGlobalBlock__: 0x10a4a9148>

简单来说分两种情况
A、没有引用外部变量 --- block存放在全局区
B、引用了外部变量----显式声明为weak类型的block则存放在栈区，反之则是存在在堆区的，也就是说block是strong类型的。

内存分区

iOS App的内存分配大概如下所示

image.png

使用block的注意事项

因为在ARC中，block还是有可能为NSStackBlock类型的，也就是说，随着作用域结束，block将会销毁回收。
所以有时候需要对block进行copy操作，手动复制到堆区内存中，防止被回收，导致block无法使用。

自动copy

以下情况，系统会将block自动复制到堆上，自动对block调用copy方法。
1、当 block 作为函数返回值返回时；
2、当 block 被赋值给__strong修饰的 id 类型的对象或 block 对象时；
3、当 block 作为参数被传入方法名带有 usingBlock 的 Cocoa Framework 方法或 GCD 的 API 时。

因为在ARC下，对象默认是用__strong修饰的，所以大部分情况下编译器都会将 block从栈自动复制到堆上，所以iOS编程中，一般声明block的property修饰符为copy，显示地说明是在堆区的，ARC会自动完成从栈区copy到堆区的操作，当然使用 strong 去修饰 block 也是没有问题的，还是一样会自动copy。

不自动copy

以下情况，系统不会自动复制到堆上，也就是说，作用域结束，block就被回收销毁。
block 作为方法或函数的参数传递。
block 作为临时变量，没有赋值给其他block

注意，上述不一定是从栈区复制到堆区，也有可能是global 区复制过去的。

__block的探究

捕获变量

• 自动变量
  Block捕获外部自动变量是传值的方式捕获的， Block只能访问此变量的值，也非通过此变量的内存地址访问。

• 非自动变量
  Block捕获静态变量时，是通过传递该静态变量的内存地址
  Block捕获全局区变量是，因为作用域是全局，Block也可以直接修改。

• 总结
  Block本质上是一个匿名函数，对于函数来说，捕获变量可以理解为传递参数。

至于为什么OC没有默认就给自动变量设置为指针传值，是因为栈区的随着函数作用域结束而结束，而Block可能会强引用而被copy到堆区，这时候Block还引用自动变量就不合适。

修改值

由上面可知，如果想在Block内部修改外部变量的值有两个方法可以做到

• 传值为内存地址方式
• 改变变量在内存中的位置

在OC中，对栈区的自动变量加了前缀__block后，Block就会创建一个带isa指针的构体来替换*原本的自动变量，里面存放着该变量的内存地址等信息。

注意，这里是替换

如原代码，定义block，让block修改自动变量 autoValue。

typedef void (^MyBlock)(void);

int main(int argc, char * argv[]) {
    __block int autoValue = 1;
    MyBlock co_block = ^{
        autoValue = 2;
    };
    autoValue = 3;
    co_block();
    autoValue = 999;
    return 0;;
}

使用Clang转化为cpp
clang -rewrite-objc main.m
可得到关键cpp代码如下

typedef void (*MyBlock)(void);

struct __Block_byref_autoValue_0 {
  void *__isa;
__Block_byref_autoValue_0 *__forwarding;
 int __flags;
 int __size;
 int autoValue;
};

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __Block_byref_autoValue_0 *autoValue; // by ref
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_autoValue_0 *_autoValue, int flags=0) : autoValue(_autoValue->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  __Block_byref_autoValue_0 *autoValue = __cself->autoValue; // bound by ref

        (autoValue->__forwarding->autoValue) = 2;
    }
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->autoValue, (void*)src->autoValue, 8/*BLOCK_FIELD_IS_BYREF*/);}

static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->autoValue, 8/*BLOCK_FIELD_IS_BYREF*/);}

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
  void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*);
  void (*dispose)(struct __main_block_impl_0*);
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0), __main_block_copy_0, __main_block_dispose_0};
int main(int argc, char * argv[]) {
    __attribute__((__blocks__(byref))) __Block_byref_autoValue_0 autoValue = {(void*)0,(__Block_byref_autoValue_0 *)&autoValue, 0, sizeof(__Block_byref_autoValue_0), 1};
    MyBlock co_block = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_autoValue_0 *)&autoValue, 570425344));
    (autoValue.__forwarding->autoValue) = 3;
    ((void (*)(__block_impl *))((__block_impl *)co_block)->FuncPtr)((__block_impl *)co_block);
    (autoValue.__forwarding->autoValue) = 999;
    return 0;;
}
static struct IMAGE_INFO { unsigned version; unsigned flag; } _OBJC_IMAGE_INFO = { 0, 2 };

由上面cpp代码可知
当自动变量被加上__block后，原本的变量就替换为一个结构体类型，这个结构体中存在原本的自动变量int autoValue和，和一个__forwarding指针，这个指针的类型是此结构体，而Block内部访问和后续Block外面访问这个自动变量全部替换成如下
新变量->__forwarding->原变量同类型变量
如

(autoValue.__forwarding->autoValue) = 3;
(autoValue.__forwarding->autoValue) = 999;

注意

对自动变量加__block其实和block没有必要的联系。
就算没有block捕获自动变量，我们对一个自动变量加上__block，oc也会在编译时把他替换为一个结构体类型。如

int main(int argc, char * argv[]) {
    __block int autoValue = 1;
    autoValue = 999;
    return 0;;
}

转化后如下

struct __Block_byref_autoValue_0 {
  void *__isa;
__Block_byref_autoValue_0 *__forwarding;
 int __flags;
 int __size;
 int autoValue;
};
int main(int argc, char * argv[]) {
    __attribute__((__blocks__(byref))) __Block_byref_autoValue_0 autoValue = {(void*)0,(__Block_byref_autoValue_0 *)&autoValue, 0, sizeof(__Block_byref_autoValue_0), 1};
    (autoValue.__forwarding->autoValue) = 999;
    return 0;;
}
static struct IMAGE_INFO { unsigned version; unsigned flag; } _OBJC_IMAGE_INFO = { 0, 2 };

对象类型也同理。

总结

__block的作用就是原地构建一个新的结构体来替换原本的自动变量，使得block捕获这个自动变量时，可以使用指针访问，这样就可以修改这个自动变量的值了。

需要注意的是
这个自动变量被替换为结构体后，其实还是一个自动变量，生命周期会随着函数结束而结束，但是平常使用的Block一般都是存放在堆区的，而且Block里面的变量也是存在堆区，Bloc捕获外面的自动变量时，会将变量从栈空间copy 到堆空间。

当__block变量是在栈空间，其__forwarding指针指向自身，当变量从栈空间copy到堆空间时，原来栈空间的变量的forwarding指向了新创建的变量（堆空间上），这样block里面也能改变原变量。