Block简介

Block的使用

1.Block属性

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

通常我们用copy来修饰Block属性，其实在ARC下系统已经自动将Block拷贝到堆中，所以用strong和copy效果相同。但便于统一，所以copy修饰Block的习惯就保留下来了。
2.方法中Block参数

- (void)action:(void(^)(void)) {
}

Block是能够自动捕获外界变量的匿名函数，也是一个对象

在iOS中，对象和类对象都是结构体，首地址是isa指针，而Block本身也是结构体，所以首地址是isa指针的Block就是一个对象类型，原因在下方“__block原理”。

Block循环引用的经典例子

Block循环引用的经典例子

解决循环引用问题

循环引用的主要原因是 self -> block -> self 的持有方式，导致self无法释放，破解的办法就是打破这个持有方式，增加中间量。

// 循环引用的解决办法

@property (nonatomic, strong) NSString *name;
@property (nonatomic, copy) void(^block)(void);

// 1. weak strong dance
self.name = @"test";
__weak typeof(self) weakSelf = self;
self.block = ^{
    // 使用__strong的原因是如果self被释放了，那么打印的是null
    // 持有链是self -> block -> strongSelf -> self，strongSelf是局部变量，会被释放，所以可以打破循环
    __strong typeof(self) strongSelf = weakSelf;
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"%@", strongSelf.name);
    });
};

// 2. 使用中间变量
__block ViewController *vc = self;
self.block = ^{
    // 持有链是self -> block -> vc -> self，vc是外部变量，手动释放后也可打破循环
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"%@", strongSelf.name);
        vc = nil;
    });
};

// 3.将需要引用的数据当做Block参数，传入到代码块中
@property (nonatomic, copy) void(^block)(ViewController *vc);
self.block = ^(ViewController *vc) {
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"%@", vc.name);
    });
};

Block在内存中的位置常用的有3种

Block在内存中的位置

Block普遍根据操作数据的分区来决定自己的位置，防止跨区操作消耗性能。

如果外部变量不用__block修饰，为什么在Block内部不可以修改该变量

1.我们先看下面的代码

__block int a = 10;
NSLog(@"操作前:%p", &a);
void(^block)(void) = ^{
    a ++;
    NSLog(@"操作中:%p", &a);
};
block();
NSLog(@"操作后:%p", &a);

打印结果如下

__block修饰变量的内存变化

由此我们可以得到一个暂时的结论：数据从栈拷贝到了堆区。
但这个结论是否正确，我们还要进一步验证。

为了验证我们刚刚的结论，我们进行底层编译。
在Terminal中创建一个.c文件，写入如下代码：

#include "stdio.h"
int main() {
    void(^block)(void) = ^{
        printf("block\n");
    };
    block();
    return 0;
}

使用gcc进行编译得到的a.out，再执行a.out，打印出block，
再使用clang -rewrite-objc blockTest.c -o blockCPP.cpp，得到并打开C++文件：

// 其中有个__main_block_impl_0，我们搜索一下，找到对应的结构体
// 其中__block_impl就是Block的结构体
struct __main_block_impl_0 {
    struct __block_impl impl;
    struct __main_block_desc_0* Desc;
    // fp就是Block代码块的实现指针
    __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
        // 根据impl.isa，可以得出Block是一个对象(源码中的NSObject协议里面有一个isa)。
        impl.isa = &_NSConcreteStackBlock;
        impl.Flags = flags;
        impl.FuncPtr = fp;    // 将fp赋值给属性函数进行保存
        Desc = desc;
    }
};

// Block代码块的底层函数
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
    printf("block - %d", a);
}

int main() {
    void(*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
    ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
    return 0;

    // 简化为下方
    // 为什么要调用Block的原因也清楚了，第一步只是定义了Block，将fp赋值给funcPtr，但并没有调用方法
    id block = __main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA);
    block->FuncPtr(block);
}

由此我们可以得到一些结论：Block中自定义的代码块本质也是一个函数，创建Block时将该函数指针保存在Block结构体中。

2.接着我们重新编译blockTest.c，将代码改为下方：

#include "stdio.h"
int main() {
    int a = 10;
    void(^block)(void) = ^{
        printf("block - %d\n", a);
    };
    block();
    return 0;
}

clang之后的C++代码如下：

struct __main_block_impl_0 {
    struct __block_impl impl;
    struct __main_block_desc_0* Desc;
    // 多了一个变量a
    int a;
    /// 构造函数也多了一个参数
    __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _a, int flags=0) : a(_a) {
        impl.isa = &_NSConcreteStackBlock;
        impl.Flags = flags;
        impl.FuncPtr = fp;
        Desc = desc;
    }
};

// Block的内部代码，其实就是将结构体中的变量a赋值给一个局部变量a
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
    int a = __cself->a; // bound by copy
    printf("block - %d", a);
}

int main() {
    int a = 10;
    // 创建Block时，将a赋值到Block结构体中
    void(*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, a));
    ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
    return 0;
}

我们可以看到，Block结构体中多了一个int类型的变量a，并且构造函数也多了一个参数，这其实就是Block自动捕获了外部变量a，将a赋值到结构体中进行保存。
我们无法修改变量的原因也了解到了：Block代码块中我们使用的是局部变量，所以无法修改原变量的值。

3.接下来我们将.c文件中的代码修改为：

#include "stdio.h"
int main() {
    __block int a = 10;
    void(^block)(void) = ^{
        a ++;
        printf("block - %d\n", a);
    };
    block();
    return 0;
}

clang之后获得的C++代码为：

// 多了一个结构体a，里面保存的是a的值和地址
struct __Block_byref_a_0 {
    void *__isa;
    __Block_byref_a_0 *__forwarding;
    int __flags;
    int __size;
    int a;
};

struct __main_block_impl_0 {
    struct __block_impl impl;
    struct __main_block_desc_0* Desc;
    // 变量a变成了结构体a
    __Block_byref_a_0 *a; // by ref
    __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_a_0 *_a, int flags=0) : a(_a->__forwarding) {
        impl.isa = &_NSConcreteStackBlock;
        impl.Flags = flags;
        impl.FuncPtr = fp;
        Desc = desc;
    }
};

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
    // 修改的是结构体中的a的值
    __Block_byref_a_0 *a = __cself->a; // bound by ref
    (a->__forwarding->a) ++;
    printf("block - %d", (a->__forwarding->a));
}

int main() {
    // __block的本质就是创建一个结构体，将变量a的值和原来的地址保存到结构体中
    __attribute__((__blocks__(byref))) __Block_byref_a_0 a = {(void*)0,(__Block_byref_a_0 *)&a, 0, sizeof(__Block_byref_a_0), 10};
    void(*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_a_0 *)&a, 570425344));
    ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
    return 0;

    // 简化如下
    __Block_byref_a_0 a = {
        (void*)0,
        (__Block_byref_a_0 *)&a, 
        0, 
        sizeof(__Block_byref_a_0), 
        10};
    void(*block)(void) = &__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_a_0 *)&a, 570425344);
    block->FuncPtr(block);
}

所以我们得到的暂时结论：“数据从栈拷贝到堆上”是不准确的。

总结：

1.Block是一个对象，底层是一个结构体，保存自定义代码的函数指针
2.未使用__block情况下捕获到外部变量a时，将外部变量a赋值到Block结构体中的变量进行保存，自定义代码中调用时使用的是新创建局部变量a1，所以无法修改外部变量a的值。
3.__block的本质是创建一个结构体也是对象as，所以我们之前打印的地址是堆的地址。as中保存了变量a的地址和值，自定义代码中修改的就是结构体as中a的值。