iOS 底层探索： 学习大纲 OC篇

前言

• 关于Block我们用的已经非常多了，其实Block完整称为Block代码块，是一个独立的代码片段，存在于另一个编程结构的范围内, block 是 C 语言的扩充功能，我们可以认为它是 带有自动变量的匿名函数，同时也是一个对象。为了进一步了解block，这篇开始探究Block的底层原理。
• 可编译的libclosure-74源码下载

目录

• 1.block的基础
• 2.block的内存分配
• 3.block的循环引用
• 4.block的本质
• 5.block的源码解读

一、block的基础

** block创建的规则和使用的方法**

block定义分为两个模块。

• block变量（block：block代码块定义的声明的变量名）
• 表达式（block：独立的代码片）

1. block 变量

block块变量的定义和使用函数指针引用C函数的方式相同，您可以声明一个变量来跟踪块，如下所示：

void (^simpleBlock)(void);
返回值类型 (^变量名)(参数列表)

2. block 表达式

block块 表达式和C匿名函数的方法表达式相同。

^ int (int count) {
return count + 1;
};
^ 返回值类型 (参数列表) {表达式}

3. block块使用

如下声明了一个变量名为HJBlock的Block：

int (^ HJBlock)(int) = ^(int count) {
        return count + 1;
    };

当Block类型变量作为属性时 ： 延长block的使用时间使用copy修饰

typedef int (^ HJBlock)(int);
@property(copy) HJBlock blk;

-(void)initBlockProperty{
      _ blk = ^(int count) {
        return count + 1;
    };
}
-(void)action{
    _ blk();
}

当Block类型变量作为函数的参数时

- (void)func:(int (^)(int))blk {
    NSLog(@"Param:%@", blk);
}
或者
typedef int (^ HJBlock)(int);

- (void)func:(HJBlock)blk {
    NSLog(@"Param:%@", blk);
}

Block类型变量作返回值时

- (int (^)(int))funcR {
    return ^(int count) {
        return count ++;
    };
}
或者
typedef int (^ HJBlock)(int);

- (HJBlock)funcR {
    return ^(int count) {
        return count ++;
    };
}

二 、block的内存分配

NSGlobalBlock 全局类型block，存储在内存中的全局区，这种情况下block，无传入参数无返回值。

void(^block)(void) = ^{
    NSLog(@"hello,block");
};
NSLog(@"%@", block);

<__NSGlobalBlock__: 0x1065fa088>
不访问栈区的变量（如局部变量），且不访问堆区的变量（如用alloc创建的对象）时，此时block存放在代码区

NSMallocBlock 堆区类型block，存储在内存中的堆区，这种情况下block会访问外部变量a，对a进行值copy。

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

<__NSMallocBlock__: 0x600003305680>

NSStackBlock 栈区类型block，存储在内存中的栈区，这种情况打印的是未赋值给block对象的一种形态，一旦完成赋值，对a进行拷贝持有，就会变为栈区block。

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

<__NSStackBlock__: 0x7ffeec33f518>

这种 block，在 MRC 中，是 StackBlock 。在 ARC 中，因为编译器做了优化，自动进行了 copy ，这种就是 MallocBlock 了。

优化的原因：

• 如果 StackBlock 访问了一个自动变量，因为自己是存在栈上的，所以变量也就会被保存在栈上。但是因为栈上的数据是由系统自动进行管理的，随时都有可能被回收，非常容易造成野指针的问题。

• ARC 机制会自动将栈上的 block 复制到堆上，所以，ARC 下的 block 的属性关键词其实使用 strong 和 copy 都不会有问题，习惯使用 copy 吧。

• ARC 环境下，一旦 block 赋值就会触发 copy，block 就会 copy 到堆上，block也就会变成 __NSMallocBlock 。
• 当然，如果刻意的去写（没有实际用处），ARC 环境下也是存在 __NSStackBlock 的，这种情况下，block 就在栈上。

总结

三、block的循环引用

block循环引用的案列：

NSString *name = @"hj";
self.block = ^(void){
    NSLog(@"%@",self.name);
};
self.block();

因为在block内部使用了外部变量name，导致block持有了self，而self原本是持有block的，所以导致了self和block的相互持有,所以造成了循环引用。

解决方案1：ARC下 weak-stong-dance

如果block内部并未嵌套block，直接使用__weak修饰self即可

typedef void(^ HJBlock)(void);

@property(nonatomic, copy) HJBlock SBlock;

__weak typeof(self) weakSelf = self;
self.SBlock = ^(void){
     NSLog(@"%@",weakSelf.name);
}

如果block内部嵌套block，需要同时使用__weak 和 __strong

__weak typeof(self) weakSelf = self;
self. SBlock = ^(void){
    __strong typeof(weakSelf) strongSelf = weakSelf;
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"%@",strongSelf.name);
    });
};
self.SBlock();

• 其中strongSelf是一个临时变量，在SBlock的作用域内，即内部block执行完就释放strongSelf
  这种方式属于打破self对block的强引用，依赖于中介者模式，属于自动置为nil，即自动释放

解决方案2 ： __block修饰变量

__block ViewController *vc = self;
self.SBlock = ^(void){
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"%@",vc.name);
        vc = nil;//手动释放
    });
};
self.SBlock();

• 这种方式同样依赖于中介者模式，属于手动释放，是通过__block修饰对象，主要是因为__block修饰的对象是可以改变的

【注意点 ：】这里的block必须调用，如果不调用block，vc就不会置空，那么依旧是循环引用，self和block都不会被释放

解决方案3：将self作为参数

typedef void(^ HJBlock)(ViewController *);

@property(nonatomic, copy) HJBlock SBlock;

self. SBlock = ^(ViewController *vc){
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"%@",vc.name);
    });
};
self. SBlock(self);

• 将对象self作为参数，提供给block内部使用，不会有引用计数问题

四、block的本质

举例分析：

int main() {
    int count = 100;
    void (^ blk)() = ^(){
        NSLog(@"In Block:%d", count);
    };
    blk();
}

通过使用Clang把Block解析成C++源码

xcrun -sdk iphonesimulator clang -arch x86_64 -rewrite-objc block.c

int main() {
    int count = 100;
    void (* blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, count));
    ((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
}

从解析出来的源代码看，main内包含一个__main_block_impl_0的Block块，而定义的Block块被解析成__block_impl，接下来看一下这些内容Block块的具体内容。

// main_block 块
struct __main_block_impl_0 {
  struct __block_impl impl;   //定义的那个block块
  struct __main_block_desc_0* Desc;   // main Block的描述
  int count;                          //定义的那个count

//  block 实现内部实现细节赋值等内容
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _count, int flags=0) : count(_count) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};


// 主要是block块对count进行复制出来
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  int count = __cself->count; // bound by copy
                                             // __cself相当于Objective-C中的self
        NSLog((NSString *)&__NSConstantStringImpl__var_folders_d0_ts4pl5295tnfzz5ls4lj_z8w0000gp_T_main2_e76fdd_mi_0, count);
}

// block块的描述 
static struct __main_block_desc_0 {
  size_t reserved;   // block块预留的内存
  size_t Block_size;   // block块的内存
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};

// Block块的结构体
struct __block_impl {   
  void *isa;
  int Flags;
  int Reserved;
  void *FuncPtr;
};

• 在Objective-C中，任何类的定义都是对象。类和类的实例（对象）没有任何本质上的区别。任何对象都有isa指针。block块中包含isa，验证苹果文档说Block是Object-C的对象。

• block的本质是对象、函数、结构体，由于block函数没有名称，也被称为匿名函数

1、block为什么需要被调用

在底层block的类型__main_block_impl_0结构体，通过其同名构造函数创建，第一个传入的block的内部实现代码块，即__main_block_func_0，用fp表示，然后赋值给impl的FuncPtr属性，然后在main中进行了调用，这也是block为什么需要调用的原因。如果不调用，block内部实现的代码块将无法执行，可以总结为以下两点

• 函数声明：即block内部实现声明成了一个函数__main_block_func_0

• 执行具体的函数实现：通过调用block的FuncPtr指针，调用block执行

2、block是如何获取外界变量的

定义一个变量，并在block中调用

int main(){
    int a = 11;
    void(^block)(void) = ^{
        printf(" TEST- %d", a);
    };
    
     block();
}

编译后：

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int a;//编译时就自动生成了相应的变量
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _a, int flags=0) : a(_a) {
    impl.isa = &_NSConcreteStackBlock;//block的isa默认是stackBlock
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  int a = __cself->a; // bound by copy 值拷贝，即 a = 10，此时的a与传入的__cself的a并不是同一个

        printf("TEST - %d", a);
}
    
int main(){

    int a = 11;
    void(*block)(void) = __main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA, a));

     block)->FuncPtr(block);
}

• __main_block_func_0中的a是值拷贝，如果此时在block内部实现中作 a++操作，是有问题的，会造成编译器的代码歧义，即此时的a是只读的

【总结】：block捕获外界变量时，在内部会自动生成同一个属性来保存

3、__block的原理

对a加一个__block，然后在block中对a进行++操作

int main(){

    __block int a = 11;
    void(^block)(void) = ^{
        a++;
        printf("TEST - %d", a);
    };
    
     block();
    return 0;
}

底层编译为如下

struct __Block_byref_a_0 {//__block修饰的外界变量的结构体
  void *__isa;
__Block_byref_a_0 *__forwarding;
 int __flags;
 int __size;
 int a;
};

struct __main_block_impl_0 {//block的结构体类型
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __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) {//block内部实现
  __Block_byref_a_0 *a = __cself->a; // bound by ref 指针拷贝，此时的对象a 与 __cself对象的a 指向同一片地址空间
        //等同于 外界的 a++
        (a->__forwarding->a)++;
        printf("TEST  - %d", (a->__forwarding->a));
    }
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->a, (void*)src->a, 8/*BLOCK_FIELD_IS_BYREF*/);}

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

int main(){
    //__Block_byref_a_0 是结构体，a 等于 结构体的赋值，即将外界变量a 封装成对象
    //&a 是外界变量a的地址
    __attribute__((__blocks__(byref))) __Block_byref_a_0 a = {(void*)0,(__Block_byref_a_0 *)&a, 0, sizeof(__Block_byref_a_0), 11};
    //__main_block_impl_0中的第三个参数&a，是封装的对象a的地址
    void(*block)(void) = __main_block_impl_0(__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;
}

分析：

• main中的a是通过外界变量封装的对象

• __main_block_impl_0中，将对象a的地址&a给构造函数

• 在__main_block_func_0内部对a的处理是指针拷贝，此时创建的对象a与传入对象的a指向同一片内存空间

总结：

• 外界变量会生成__Block_byref_a_0结构体

• 结构体用来保存原始变量的指针和值

• 将变量生成的结构体对象的指针地址 传递给block，然后在block内部就可以对外界变量进行操作了

对比

• 值拷贝 - 深拷贝，只是拷贝数值，且拷贝的值不可更改，指向不同的内存空间，案例中普通变量a就是值拷贝

• 指针拷贝 - 浅拷贝，生成的对象指向同一片内存空间，案例中经过__block修饰的变量a就是指针拷贝

五、block的源码解读

源码的追踪

新建一个项目然后开启汇编调试：注意尽量要在新建的项目里，旧项目有缓存，我验证了多次，清除缓存也没用。编译器进行优化，省略的一些符号。所以最好要在新建的项目中调试。

block的真正类型

可以到苹果开源网站下载最新的libclosure-74源码,通过查看_Block_copy的源码实现，发现block在底层的真正类型是Block_layout，查看源码如下：

// 注释:Block 结构体
struct Block_layout {
    //指向表明block类型的类
    void *isa;//8字节 指向表明block类型的类
    //用来作标识符的，类似于isa中的位域,按bit位表示一些block的附加信息
    volatile int32_t flags; // contains ref count 4字节
    //保留信息，可以理解预留位置，用于存储block内部变量信息
    int32_t reserved;//4字节
    //函数指针，指向具体的block实现的调用地址
    BlockInvokeFunction invoke; 
    //block的附加信息, 比如保留变量数、block的大小、进行copy或dispose的辅助函数指针
    struct Block_descriptor_1 *descriptor;
    // imported variables
};

注：

• flags：标识符，按bit位表示一些block的附加信息，类似于isa中的位域，其中flags的种类有以下几种

// 注释: flags 标识
// Values for Block_layout->flags to describe block objects
enum {
    //释放标记，一般常用于BLOCK_BYREF_NEEDS_FREE做位与运算，一同传入flags，告知该block可释放
    BLOCK_DEALLOCATING =      (0x0001),  // runtime
    //存储引用引用计数的 值，是一个可选用参数
    BLOCK_REFCOUNT_MASK =     (0xfffe),  // runtime
    //低16位是否有效的标志，程序根据它来决定是否增加或者减少引用计数位的值
    BLOCK_NEEDS_FREE =        (1 << 24), // runtime
    //是否拥有拷贝辅助函数，（a copy helper function）决定block_description_2
    BLOCK_HAS_COPY_DISPOSE =  (1 << 25), // compiler
    //是否拥有block C++析构函数
    BLOCK_HAS_CTOR =          (1 << 26), // compiler: helpers have C++ code
    //标志是否有垃圾回收，OSX
    BLOCK_IS_GC =             (1 << 27), // runtime
    //标志是否是全局block
    BLOCK_IS_GLOBAL =         (1 << 28), // compiler
    //与BLOCK_HAS_SIGNATURE相对，判断是否当前block拥有一个签名，用于runtime时动态调用
    BLOCK_USE_STRET =         (1 << 29), // compiler: undefined if !BLOCK_HAS_SIGNATURE
    //是否有签名
    BLOCK_HAS_SIGNATURE  =    (1 << 30), // compiler
    //使用有拓展，决定block_description_3
    BLOCK_HAS_EXTENDED_LAYOUT=(1 << 31)  // compiler
};

• descriptor：block的附加信息分三类 ：Block_descriptor_1是必选的Block_descriptor_2 和 Block_descriptor_3都是可选的

//一定有，包含了保留信息和保留位的大小
#define BLOCK_DESCRIPTOR_1 1
struct Block_descriptor_1 { 
    uintptr_t reserved;//保留信息
    uintptr_t size;//block大小
};

//不一定有，看flag中的BLOCK_HAS_COPY_DISPOSE，包含了block可以进行copy和dispose的函数指针。
#define BLOCK_DESCRIPTOR_2 1
struct Block_descriptor_2 { 
    // requires BLOCK_HAS_COPY_DISPOSE
    BlockCopyFunction copy;//拷贝函数指针
    BlockDisposeFunction dispose;
};

//不一定有，看的flag中BLOCK_HAS_SIGNATURE和BLOCK_HAS_EXTENDED_LAYOUT，包含了签名。
#define BLOCK_DESCRIPTOR_3 1
struct Block_descriptor_3 { 
    // requires BLOCK_HAS_SIGNATURE
    const char *signature;//签名
    const char *layout;     // contents depend on BLOCK_HAS_EXTENDED_LAYOUT 布局
};

关于descriptor的可以从其构造函数中体现，其中Block_descriptor_2和Block_descriptor_3 都是通过 Block_descriptor_1的地址，经过内存平移得到的

static struct Block_descriptor_1 * _Block_descriptor_1(struct Block_layout *aBlock)
{
    return aBlock->descriptor;//默认打印
}
#endif

// 注释:Block 的描述 : copy 和 dispose 函数
static struct Block_descriptor_2 * _Block_descriptor_2(struct Block_layout *aBlock)
{
    if (! (aBlock->flags & BLOCK_HAS_COPY_DISPOSE)) return NULL;
    uint8_t *desc = (uint8_t *)aBlock->descriptor;//descriptor_1的地址
    desc += sizeof(struct Block_descriptor_1);//通过内存平移获取
    return (struct Block_descriptor_2 *)desc;
}

// 注释: Block 的描述 : 签名相关
static struct Block_descriptor_3 * _Block_descriptor_3(struct Block_layout *aBlock)
{
    if (! (aBlock->flags & BLOCK_HAS_SIGNATURE)) return NULL;
    uint8_t *desc = (uint8_t *)aBlock->descriptor;
    desc += sizeof(struct Block_descriptor_1);
    if (aBlock->flags & BLOCK_HAS_COPY_DISPOSE) {
        desc += sizeof(struct Block_descriptor_2);
    }
    return (struct Block_descriptor_3 *)desc;
}

block签名

分析

• block在底层本质是Block_layout，其参数中isa占8字节，flags占4字节，reserved占4字节，invoke占8字节，descriptor占8字节，所以我们读取的第一个4段内存中的第4个就是descriptor的地址；
• Block_descriptor_3的地址是由Block_descriptor_1偏移进行读取的，根据_Block_descriptor_3函数中的代码，我们的Block是否需要销毁通过BLOCK_HAS_COPY_DISPOSE进行判断，在读取的第一个四段内存中的第二段0x0000000000000020与上flags中的BLOCK_HAS_COPY_DISPOSE也就是1 << 25结果为0，所以只需要偏移Block_descriptor_1这个结构体的内存大小；
• Block_descriptor_1有两个属性，分别都是uintptr_t类型，uintptr_t实际就是long占8字节，两个就是16字节，所以第二个四段内存中的第三个就是Block_descriptor_3的首地址，也就是signature签名信息的地址，是个char *类型，占8字节。打印结果为v8@?0，所以这就是我们当前Block的签名。

签名信息分析：

打印签名po [NSMethodSignature signatureWithObjCTypes:"v8@?0"]

//无返回值
return value: -------- -------- -------- --------
    type encoding (v) 'v'
    flags {}
    modifiers {}
    frame {offset = 0, offset adjust = 0, size = 0, size adjust = 0}
    memory {offset = 0, size = 0}
argument 0: -------- -------- -------- --------
    //encoding = (@),类型是 @?
    type encoding (@) '@?'
    //@是isObject ，？是isBlock，代表 isBlockObject
    flags {isObject, isBlock}
    modifiers {}
    frame {offset = 0, offset adjust = 0, size = 8, size adjust = 0}
    //所在偏移位置是8字节
    memory {offset = 0, size = 8}

结论：

• block的签名为@?
• block的签名信息类似于方法的签名信息，主要是体现block的返回值，参数以及类型等信息

block的三层copy(一)

// Copy, or bump refcount, of a block.  If really copying, call the copy helper if present.
// 重点提示: 这里是核心重点 block的拷贝操作: 栈Block -> 堆Block
void *_Block_copy(const void *arg) {
    struct Block_layout *aBlock;

    if (!arg) return NULL;
    
    // The following would be better done as a switch statement
    aBlock = (struct Block_layout *)arg;//强转为Block_layout类型对象，防止对外界造成影响
    if (aBlock->flags & BLOCK_NEEDS_FREE) {//是否需要释放
        // latches on high
        latching_incr_int(&aBlock->flags);
        return aBlock;
    }
    else if (aBlock->flags & BLOCK_IS_GLOBAL) {//如果是全局block，直接返回
        return aBlock;
    }
    else {//为栈block 或者 堆block，由于堆区需要申请内存，所以只可能是栈区
        // Its a stack block.  Make a copy. 它是一个堆栈块block，拷贝。
        struct Block_layout *result =
            (struct Block_layout *)malloc(aBlock->descriptor->size);//申请空间并接收
        if (!result) return NULL;
        //通过memmove内存拷贝，将 aBlock 拷贝至result
        memmove(result, aBlock, aBlock->descriptor->size); // bitcopy first
#if __has_feature(ptrauth_calls)
        // Resign the invoke pointer as it uses address authentication.
        result->invoke = aBlock->invoke;//可以直接调起invoke
#endif
        // reset refcount
        result->flags &= ~(BLOCK_REFCOUNT_MASK|BLOCK_DEALLOCATING);    // XXX not needed 告知可释放
        result->flags |= BLOCK_NEEDS_FREE | 2;  // logical refcount 1
        _Block_call_copy_helper(result, aBlock);
        // Set isa last so memory analysis tools see a fully-initialized object.
        result->isa = _NSConcreteMallocBlock;//设置block对象类型为堆区block
        return result;
    }
}

进入_Block_copy源码，将block 从栈区拷贝至堆区

• 如果需要释放，如果需要则直接释放

• 如果是globalBlock 不需要copy，直接返回

• 反之，只有两种情况：栈区block or 堆区block，由于堆区block需要申请空间，前面并没有申请空间的相关代码，所以只能是栈区block，

  • 通过malloc申请内存空间用于接收block
  • 通过memmove将block拷贝至新申请的内存中
  • 设置block对象的类型为堆区block，即result->isa = _NSConcreteMallocBlock

_Block_object_assign 分析

想要分析block的三层copy，首先需要知道外部变量的种类有哪些，其中用的最多的是BLOCK_FIELD_IS_OBJECT和BLOCK_FIELD_IS_BYREF

// 注释: Block 捕获的外界变量的种类
// Runtime support functions used by compiler when generating copy/dispose helpers

// Values for _Block_object_assign() and _Block_object_dispose() parameters
enum {
    // see function implementation for a more complete description of these fields and combinations
    //普通对象，即没有其他的引用类型
    BLOCK_FIELD_IS_OBJECT   =  3,  // id, NSObject, __attribute__((NSObject)), block, ...
    //block类型作为变量
    BLOCK_FIELD_IS_BLOCK    =  7,  // a block variable
    //经过__block修饰的变量
    BLOCK_FIELD_IS_BYREF    =  8,  // the on stack structure holding the __block variable
    //weak 弱引用变量
    BLOCK_FIELD_IS_WEAK     = 16,  // declared __weak, only used in byref copy helpers
    //返回的调用对象 - 处理block_byref内部对象内存会加的一个额外标记，配合flags一起使用
    BLOCK_BYREF_CALLER      = 128, // called from __block (byref) copy/dispose support routines.
};

而_Block_object_assign是在底层编译代码中，外部变量拷贝时调用的方法就是它

• 进入_Block_object_assign源码

  • 如果是普通对象，则交给系统arc处理，并拷贝对象指针，即引用计数+1，所以外界变量不能释放

  • 如果是block类型的变量，则通过_Block_copy操作，将block从栈区拷贝到堆区

  • 如果是__block修饰的变量，调用_Block_byref_copy函数 进行内存拷贝以及常规处理

static struct Block_byref *_Block_byref_copy(const void *arg) {

    //强转为Block_byref结构体类型，保存一份
    struct Block_byref *src = (struct Block_byref *)arg;

    if ((src->forwarding->flags & BLOCK_REFCOUNT_MASK) == 0) {
        // src points to stack 申请内存
        struct Block_byref *copy = (struct Block_byref *)malloc(src->size);
        copy->isa = NULL;
        // byref value 4 is logical refcount of 2: one for caller, one for stack
        copy->flags = src->flags | BLOCK_BYREF_NEEDS_FREE | 4;
        //block内部持有的Block_byref 和 外界的Block_byref 所持有的对象是同一个，这也是为什么__block修饰的变量具有修改能力
        //copy 和 scr 的地址指针达到了完美的同一份拷贝，目前只有持有能力
        copy->forwarding = copy; // patch heap copy to point to itself
        src->forwarding = copy;  // patch stack to point to heap copy
        copy->size = src->size;
        //如果有copy能力
        if (src->flags & BLOCK_BYREF_HAS_COPY_DISPOSE) {
            // Trust copy helper to copy everything of interest
            // If more than one field shows up in a byref block this is wrong XXX
            //Block_byref_2是结构体，__block修饰的可能是对象，对象通过byref_keep保存，在合适的时机进行调用
            struct Block_byref_2 *src2 = (struct Block_byref_2 *)(src+1);
            struct Block_byref_2 *copy2 = (struct Block_byref_2 *)(copy+1);
            copy2->byref_keep = src2->byref_keep;
            copy2->byref_destroy = src2->byref_destroy;

            if (src->flags & BLOCK_BYREF_LAYOUT_EXTENDED) {
                struct Block_byref_3 *src3 = (struct Block_byref_3 *)(src2+1);
                struct Block_byref_3 *copy3 = (struct Block_byref_3*)(copy2+1);
                copy3->layout = src3->layout;
            }
            //等价于 __Block_byref_id_object_copy
            (*src2->byref_keep)(copy, src);
        }
        else {
            // Bitwise copy.
            // This copy includes Block_byref_3, if any.
            memmove(copy+1, src+1, src->size - sizeof(*src));
        }
    }
    // already copied to heap
    else if ((src->forwarding->flags & BLOCK_BYREF_NEEDS_FREE) == BLOCK_BYREF_NEEDS_FREE) {
        latching_incr_int(&src->forwarding->flags);
    }

    return src->forwarding;
}

• 进入_Block_byref_copy源码

  • 将传入的对象，强转为Block_byref结构体类型对象，保存一份

  • 没有将外界变量拷贝到堆，需要申请内存，其进行拷贝

  • 如果已经拷贝过了，则进行处理并返回

  • 其中copy 和src的forwarding指针都指向同一片内存，这也是为什么__block修饰的对象具有修改能力的原因

static struct Block_byref *_Block_byref_copy(const void *arg) {

    //强转为Block_byref结构体类型，保存一份
    struct Block_byref *src = (struct Block_byref *)arg;

    if ((src->forwarding->flags & BLOCK_REFCOUNT_MASK) == 0) {
        // src points to stack 申请内存
        struct Block_byref *copy = (struct Block_byref *)malloc(src->size);
        copy->isa = NULL;
        // byref value 4 is logical refcount of 2: one for caller, one for stack
        copy->flags = src->flags | BLOCK_BYREF_NEEDS_FREE | 4;
        //block内部持有的Block_byref 和 外界的Block_byref 所持有的对象是同一个，这也是为什么__block修饰的变量具有修改能力
        //copy 和 scr 的地址指针达到了完美的同一份拷贝，目前只有持有能力
        copy->forwarding = copy; // patch heap copy to point to itself
        src->forwarding = copy;  // patch stack to point to heap copy
        copy->size = src->size;
        //如果有copy能力
        if (src->flags & BLOCK_BYREF_HAS_COPY_DISPOSE) {
            // Trust copy helper to copy everything of interest
            // If more than one field shows up in a byref block this is wrong XXX
            //Block_byref_2是结构体，__block修饰的可能是对象，对象通过byref_keep保存，在合适的时机进行调用
            struct Block_byref_2 *src2 = (struct Block_byref_2 *)(src+1);
            struct Block_byref_2 *copy2 = (struct Block_byref_2 *)(copy+1);
            copy2->byref_keep = src2->byref_keep;
            copy2->byref_destroy = src2->byref_destroy;

            if (src->flags & BLOCK_BYREF_LAYOUT_EXTENDED) {
                struct Block_byref_3 *src3 = (struct Block_byref_3 *)(src2+1);
                struct Block_byref_3 *copy3 = (struct Block_byref_3*)(copy2+1);
                copy3->layout = src3->layout;
            }
            //等价于 __Block_byref_id_object_copy
            (*src2->byref_keep)(copy, src);
        }
        else {
            // Bitwise copy.
            // This copy includes Block_byref_3, if any.
            memmove(copy+1, src+1, src->size - sizeof(*src));
        }
    }
    // already copied to heap
    else if ((src->forwarding->flags & BLOCK_BYREF_NEEDS_FREE) == BLOCK_BYREF_NEEDS_FREE) {
        latching_incr_int(&src->forwarding->flags);
    }

    return src->forwarding;
}

代码调试

• 定义一个__block修饰的NSString对象

 __block NSString * hj_name = [NSString stringWithFormat:@"HJ"];
void (^block1)(void) = ^{ // block_copy
    lg_name = @"HJ";
    NSLog(@"HJ - %@", hj_name);

    // block 内存
};
block1();

• xcrun编译结果如下，

  • 编译后的hj_name比普通变量多了__Block_byref_id_object_copy_131 和 __Block_byref_id_object_dispose_131

  • __Block_byref_ hj_name_0结构体中多了__Block_byref_id_object_copy和__Block_byref_id_object_dispose

//********编译后的hj_name********
 __Block_byref_ hj_name_0 hj_name =
        {(void*)0,
            (__Block_byref_ hj_name_0 *)& hj_name,
            33554432,
            sizeof(__Block_byref_ hj_name_0),
            __Block_byref_id_object_copy_131,
            __Block_byref_id_object_dispose_131,
            ((NSString * _Nonnull (*)(id, SEL, NSString * _Nonnull, ...))(void *)objc_msgSend)((id)objc_getClass("NSString"), sel_registerName("stringWithFormat:"), (NSString *)&__NSConstantStringImpl__var_folders_hr_l_56yp8j4y11491njzqx6f880000gn_T_main_9f330d_mi_0)};

//********__Block_byref_ hj_name_0结构体********
struct __Block_byref_ hj_name_0 {
  void *__isa;
__Block_byref_ hj_name_0 *__forwarding;
 int __flags;
 int __size;
 void (*__Block_byref_id_object_copy)(void*, void*);
 void (*__Block_byref_id_object_dispose)(void*);  // 5*8 = 40
 NSString * hj_name;
};

 //********__Block_byref_id_object_copy_131********
 //block自身拷贝（_Block_copy） -- __block bref结构体拷贝(_Block_object_assign) -- _Block_object_assign中对外部变量（存储在bref）拷贝一份到内存
static void __Block_byref_id_object_copy_131(void *dst, void *src) {
    //dst 外部捕获的变量，即结构体 - 5*8 = 40，然后就找到了cjl_name(cjl_name在bref初始化时就赋值了)
    _Block_object_assign((char*)dst + 40, *(void * *) ((char*)src + 40), 131);
}

 //********__Block_byref_id_object_dispose_131********
static void __Block_byref_id_object_dispose_131(void *src) {
 _Block_object_dispose(*(void * *) ((char*)src + 40), 131);
}

• 通过libclosure-74可编译源码断点调试，关键方法的执行顺序为：_Block_copy -> _Block_byref_copy -> _Block_object_assign,正好对应上述的三层copy

综上所述，block是如何取到 hj_name的？

• 1、通过_Block_copy方法，将block拷贝一份至堆区

• 2、通过_Block_object_assign方法正常拷贝，因为__block修饰的外界变量在底层是 Block_byref结构体

• 3、发现外部变量还存有一个对象，从bref中取出相应对象hj_name，拷贝至block空间，才能使用（相同空间才能使用，不同则不能使用）。最后通过内存平移就得到了hj_name，此时的hj_name 和 外界的hj_name是同一片内存空间（从_Block_object_assign方法中的*dest = object;看出）

三层copy总结

所以，综上所述，block的三层拷贝是指以下三层：

• 【第一层】通过_Block_copy实现对象的自身拷贝,从栈区拷贝至堆区

• 【第二层】通过_Block_byref_copy方法，将对象拷贝为Block_byref结构体类型

• 【第三层】调用_Block_object_assign方法，对__block修饰的当前变量的拷贝

注：只有__block修饰的对象，block的copy才有三层

_Block_object_dispose 分析

同一般的retain和release一样，_Block_object_object其本质主要是retain，所以对应的还有一个release，即_Block_object_dispose方法，其源码实现如下，也是通过区分block种类，进行不同释放操作

// When Blocks or Block_byrefs hold objects their destroy helper routines call this entry point
// to help dispose of the contents 当Blocks或Block_byrefs持有对象时，其销毁助手例程将调用此入口点以帮助处置内容
void _Block_object_dispose(const void *object, const int flags) {
    switch (os_assumes(flags & BLOCK_ALL_COPY_DISPOSE_FLAGS)) {
      case BLOCK_FIELD_IS_BYREF | BLOCK_FIELD_IS_WEAK:
      case BLOCK_FIELD_IS_BYREF://__block修饰的变量，即bref类型的
        // get rid of the __block data structure held in a Block
        _Block_byref_release(object);
        break;
      case BLOCK_FIELD_IS_BLOCK://block类型的变量
        _Block_release(object) ;
        break;
      case BLOCK_FIELD_IS_OBJECT://普通对象
        _Block_release_object(object);
        break;
      case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_OBJECT:
      case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_BLOCK:
      case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_OBJECT | BLOCK_FIELD_IS_WEAK:
      case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_BLOCK  | BLOCK_FIELD_IS_WEAK:
        break;
      default:
        break;
    }
}

• 进入_Block_byref_release源码，主要就是对象、变量的释放销毁

static void _Block_byref_release(const void *arg) {
    //对象强转为Block_byref类型结构体
    struct Block_byref *byref = (struct Block_byref *)arg;

    // dereference the forwarding pointer since the compiler isn't doing this anymore (ever?)
    byref = byref->forwarding;//取消指针引用

    if (byref->flags & BLOCK_BYREF_NEEDS_FREE) {
        int32_t refcount = byref->flags & BLOCK_REFCOUNT_MASK;
        os_assert(refcount);
        if (latching_decr_int_should_deallocate(&byref->flags)) {
            if (byref->flags & BLOCK_BYREF_HAS_COPY_DISPOSE) {//是否有拷贝辅助函数
                struct Block_byref_2 *byref2 = (struct Block_byref_2 *)(byref+1);
                (*byref2->byref_destroy)(byref);//销毁拷贝对象
            }
            free(byref);//释放
        }
    }
}

所以，综上所述，Block的三层copy的流程如下图所示