深究Block的实现

先看一下Block使用的语法

声明一个block

1 2	返回值（^名称）（参数列表）＝ ^(参数列表)｛｝；

int (^name)(int ,int) = ^(int a,int b){
     
     return （a+b）;
};

作为一个函数的参数：

- (void)testBlock:(NSString *(返回类型) (^)(int a))s（block名字） {
    NSString *a = s(1);
}
  
[self testBlock:^NSString *(int a) {
     a = 5;
     return @"1";
}];

然后通过底层代码分析一下block的实现

iOS中有三种block，下文会细说

NSConcreteGlobalBlock;//在全局中定义的
NSConcreteStackBlock; //在局部定义的
NSConcreteMallocBlock;//分配在堆中

先从最简单的看起

int main(int argc, char * argv[]) {
void (^block)(void) = ^{    
    NSLog(@"1");
};

通过在终端找到这个.m文件，然后clang -rewrite-objc 代码文件名就可以看到文件夹有个.cpp的文件，本来想变量ViewController的文件，里面用了UIKit库，编译的时候总是显示找不到，于是我编译的main.m文件

编译过来是

block源码

这里先来分析一下（便于理解）：

static void _main_block_func_0(struct _main_block_impl_0 *__cself) {
    NSLog((NSString *)&__NSConstantStringImpl__var_
    folders_yq_s_hjnhd12x79wq1ldg1jdr_w0000gn_T_main_50d1d6_mi_0);
}

可以看到，这里对应我们代码中的block中的实现，所以可以知道，block使用的匿名函数，实际上被当作一个函数来处理。不过传入的是：一个_main_block_impl_0类型的结构体，里面有一个block_impl的结构体，和一个_main_block_desc_0的结构体。跟着是他们的构造函数。
来简单看一下这个_main_block_impl_0结构体吧：

isa指向这个block的类型。这里说明这个block是NSConcreteStackBlock类型的。
flag是标志，可以看到，默认构造为0；
还有一个FuncPtr，也就是指向函数地址的指针。
还有一个__main_block_desc_0的结构体，

在下面可以看到这个结构体的初始化

一个是reserverd默认为0，
一个是block_size。是这个impl的size。

所以，这个_main_block_impl_0，我们可以理解为就是一个block实例，里面的成员变量有要执行的函数的指针，和isa（和所有的oc对象一样），还有一个size。

现在看一下main函数里面的内容

1	void (name)(void) = ((void ()())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));

这里执行的操作就是：初始化一个block实例，交给我们这么name名字变量，也就是用name这个指针指向这个block实例，执行的时候，直接找到这个block中的指向函数地址的指针。

通过以上可以了解：block的实质，就是一个对象，包含了一个指向函数首地址的指针，和一些与自己相关的成员变量。

接着看一下block访问外部变量是怎么回事，这也是我们最关心的问题。

先来看一下局部变量：

int a = 10;
int b = 20;
void (^block)() = ^ {
    NSLog(@"%d--%d",a,b);
};
block ();

block访问局部变量

首先在_main_block_impl_0的定义中看到，block中用到的变量被作为成员变量追加到了结构体中，

_main_block_impl_0(void *fp, struct _main_block_desc_0 *desc, int _a, int _b, int flags=0) : a(_a), b(_b) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
}

在初始化的时候，也需要把a和b的值传入。

1	void (*block)() = ((void ()())&_main_block_impl_0((void *)_main_block_func_0, &_main_block_desc_0_DATA, a, b));

这里看到，在初始化的时候，把a，b值传入来初始化一个_main_block_impl_0结构体。这里需要注意，传入的是a和b的值，所以我们要在结构体中改变a和b是无效的。并且编译会报错，如果要在block中改变里面的值。有以下几种方法

第一种方法是静态变量，全局变量

直接上代码吧

int global_val = 1;
static int static_global_val = 2;
int main(int argc, char * argv[]) {
    static int static_val = 3;
    void (^block)() = ^ {
        global_val = 10;
        static_global_val = 20;
        static_val = 30;
    };
    NSLog(@"%d-%d-%d", global_val, static_global_val, static_val);
    block();
    NSLog(@"%d-%d-%d", global_val, static_global_val, static_val);
}

然后rewrite一下

访问全局变量

因为这个_main_block_func_0能直接访问静态变量，所以可以直接访问这个变量的值，也可以改变，不用担心在调用这个函数的时候，全局变量访问不到，导致错误。所以这里面在调用全局变量的时候，就是很普通的调用全局变量，没有什么不同。

局部静态变量则传的是一个指针进来。因为不用担心它在函数结束时或者其他什么地方被释放，所以可以放心的访问这个值。

1
2
3

global_val = 10;
static_global_val = 20;
(*static_val) = 30;

改变的是这个指针指向的值

1	void (block)() = ((void ()())&__main_block_impl_0((void *)_main_block_func_0, &__main_block_desc_0_DATA, &static_val));

可以看到，这里传的是指针。

_main_block_func_0的作用域在main函数之外，要访问这个变量，就只能传指针。

第二种方法是给参数加__block属性

int main(int argc, char * argv[]) {
    __block int block_val = 3;
    void (^block)() = ^ {        
        block_val = 30;
    };
    NSLog(@"%d",block_val);
    block ();
    NSLog(@"%d",block_val);
    NSLog(@"%@",block);
}

__block参数

可以看到里面比其他多了一个这样的结构体_Block_byref_block_val_0

里面有：

__isa初始化为0，
__forwarding;//持有该实例自身的的指针
int __flags;为0
int __size;
int block_val;//存放这个变量的值

原来是把一个局部变量，封装成了一个结构体

赋值的时候直接给这个结构体中的这个值赋值

(block_val->__forwarding->block_val) = 30;

所以，在访问这个变量的时候，其实在访问这个结构体的这个变量。

关于__forwarding的作用请不要着急。

Block有三种类型：

NSConcreteGlobalBlock;//在全局中定义的
NSConcreteStackBlock; //在局部定义的
NSConcreteMallocBlock;//分配在堆中

设置在栈上的block，当“name这个名字变量”作用域结束时，block变量也会废弃。

所以，iOS提供了将block结构体和_block变量，复制到堆上的方法。即使block的name变量结束，那么堆上的block还可以继续访问。

而此时，_block变量结构体中的__forwarding变量可以实现，无论在堆上还是在栈上。都可以正确访问_block变量。可以理解，当把_block变量复制到堆上的时候，__forwarding就指向堆里中的自己。所以无论是访问栈中自己，还是堆中的自己，最终访问都是堆中的这个值。

一个Block对_block的内存管理方式与 ARC机制完全相同。
而_main_block_desc 中的copy和dispose就是这个 __block的retain和release操作。

那什么block在时候会复制到堆呢？

调用block的copy方法。
block作为函数返回值返回时。
block调用外面的_strong的id的类时，或用_block时。
方法中，用usingblock或者GCD中的API时。

在局部函数里，定义block时，打印出来还是NSConcreteGlobalBlock类型的

只要用了外部变量，不管是assign还是week还是strong类型的，打印出来都是NSConcreteMallocBlock类型的。

所以我猜测这会不会是苹果新版的改进，为了block在访问无效的变量，直接把block拷贝到堆上，从而也拷贝一份变量。或许是我忽略了中间的某个步骤

其实到了这里，不用再描述，也知道为什么会发生死循环，又怎么解决了。当在block中用self的时候，block拷贝到堆上，首先，在栈上的这个block有一个持有者，是name这个变量。当name这个变量作用域之外，栈上这个block就release了。，那么当block拷贝到堆上的时候，block有一个持有者是self，那么block在拷贝时，它的变量一个self指针，也会拷贝，而self又指向这个block，block持有self，self持有block，两者都不会释放。要打破这个循环，需要将self置为__week,就算拷贝一个week指针，那也不影响self的引用计数。

原文