了解 Block 的使用和原理

Block 概述

什么是 Block

    Block 是 C 语言 的扩充功能。可以用一句话来表示 Block 的扩充功能：带有自动变量(局部变量)的匿名函数。另外，“带有自动变量值的匿名函数”　这一概念并不仅指 Block，它还存在于其他许多程序语言中。在计算机科学中，此概念也称闭包（Closure）、 lambda 计算等。

Block 语法

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

Block 语法

Block类型变量

声明 Block 类型变量的示例如下：

int (^Ablk)(int);

Block 类型

Block 的类	配置存储域
NSGlobalBlock	程序的数据区域
NSMallocBlock	堆
NSStackBlock	栈

Block的分类.png

NSGlobalBlock

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

上述这段代码会输出 <__NSGlobalBlock__: 0x10f0cb098>，该类的对象 Block 设置在程序的数据区域中。

• 记述全局变量的地方有Block语法时
• Block 语法的表达式中不使用应截获的自动变量时，因为在使用全局变量的地方不能使用自动变量，所以不存在对自动变量进行截获。

在以上这些情况下，Block 为 NSGlobalBlock 类对象。即 Block 配置在程序的数据区域中。除此之外的 Block语法生成的Block，都为NSMallocBlock 或者 NSStackBlock。

NSMallocBlock

截获外界变量，且被强引用

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

上述这段代码会输出 <__NSMallocBlock__: 0x600000c65f20>，该类的对象 Block 设置在堆上。

NSStackBlock

截获外界变量，且被弱引用

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

上述这段代码会输出 <__NSStackBlock__: 0x7ff7bb9ed1a8>, 该类的对象 Block 设置在栈上。

Block 的实现

Block 的实质

    Block 是“带有自动变量值的匿名函数”，但 Block 究竟是什么呢？ Block 语法看上去好像很特别，但它实际上是作为极普通的 C 语言源代码来处理的。通过支持 Block 的编译器，含有 Block 语法的源代码转换为一般C 语言编译器能够处理的源代码，并作为极为普通的C 语言源代码被编译。
    这不过是概念上的问题，在实际编译时无法转换成我们能够理解的源代码，但 clang (LLVM 编译器)具有转换为我们可读源代码的功能。通过 -rewrite-objc 选项就能将含有 Block 语法的源代码变换为 C++ 的源代码。说是 C++ 。其实也仅是使用了 struct 结构，其本质是 C 语言源代码。

clang -rewrite-objc 源文件名称命令，示例如下：

  clang -rewrite-objc block.c

block.c 文件代码如下：

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

block.cpp 文件代码如下：

//block 对象结构体
struct __block_impl {
  void *isa;
  int Flags;
  int Reserved;
  void *FuncPtr;
};s
//区域和 Block 的大小
static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  //结构体的构造函数.
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc,int flags=0) {
    impl.isa = &_NSConcreteStackBlock; //对象
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
//与void(^block)(void) 相同的表达式，__cself 指向 Block 值的变量
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  printf("hello,block");
}

int main(){
    //将__main_block_impl_0 结构体实例的指针赋值给变量 block
    void(*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
    //这就是简单地使用函数指针调用函数,block 作为参数进行了传递 (*block->impl.FuncPtr)(block)
    ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
    return 0;
}

    可以看到，变换后的源代码中也含有相同的表达式 __main_block_func_0 。如变换后的源代码所示，通过 Blocks 使用的匿名函数实际上被作为简单的 C 语言函数来处理。另外，根据 Block 语法所属的函数名（此处为main）和该 Block 语法在该函数出现的顺序值 （此处为0）来给经 clang 变换的函数命名。
    在 main_block_impl_0 结构体构造函数中，可以看到 impl.isa= &_NSConcreteStackBlock;。 将 Block 类指针赋给 Block 的结构体成员变量 isa，为在将 Block 作为 Objective-C 对象处理时，关于该类的信息放置于 _NSConcreteStackBlock 中。

    所以，block 的本质是 Objective-C 的对象，由于 block 函数没有名称，也被称为 匿名函数 。

截获自动变量值

与之前一样，将截获自动变量值的源代码通过 clang 进行转换。

block.c 文件代码如下：

# include "stdio.h"
int main(){
    int a = 11;
    int b = 12;
    void(^block)(void) = ^{
        printf("hello,block_%d",a);
    };
    block();
    return 0;
}

block.cpp 文件代码如下：

//...省略部分代码
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;
  }
};
//函数
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  int a = __cself->a; // bound by copy  拷贝 a = 11 局部变量
  printf("hello,block_%d",a);
}
int main(){
    int a = 11;
    int b = 12;
    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 语法表达式中使用的自动变量被作为成员变量追加到了 main_block_impi_0 结构体中。请注意, Block 语法表达式中没有使用的自动变量不会被追加。Block 的自动变量截获只针对 Block 中使用的自动变量。

    在 __main_block_func_0 函数中，通过int a = __cself->a 拷贝结构体实例中保存的 a，赋值给函数中的成员变量 a。 因此，main() 函数中的 a 不会被修改。

   总的来说，所谓“截获自动变量值”意味着在执行 Block 语法时，Block 语法表达式所使用的自动变量值被保存到 Block 的结构体实例（即 Block 自身）中。

__block 标识符

    当我们在 block 内部想要修改 变量 a 的值时，会报错 error: variable is not assignable (missing __block type specifier)。如前所述，因为在实现上不能改写被截获自动变量的值，所以当编译器在编译过程中检出给被截获自动变量賦值的操作时，便产生编译错误。
    解决这个问题可以使用 __block 标识符。 下面我们来实际使用 _block 说明符，用它来指定 Block中 想变更值的自动变量。
block.c 文件代码如下：

# include "stdio.h"
int main(){
    __block int a = 11;
    int b = 12;
    void(^block)(void) = ^{
        a++;
        printf("hello,block_%d",a);
    };
    block();
    return 0;
}

block.cpp 文件代码如下：

//...省略部分代码
struct __Block_byref_val_0 {
  void *__isa;
__Block_byref_val_0 *__forwarding;
 int __flags;
 int __size;
 int val;
};

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __Block_byref_val_0 *val; // by ref
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_val_0 *_val, int flags=0) : val(_val->__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_val_0 *val = __cself->val; // bound by ref 指针拷贝

        (val->__forwarding->val)++;//实现递增
        printf("hello,block_%d",(val->__forwarding->val));
    }
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->val, (void*)src->val, 8/*BLOCK_FIELD_IS_BYREF*/);}

static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->val, 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(){
   //生成结构体
    __attribute__((__blocks__(byref))) __Block_byref_val_0 val = {(void*)0,(__Block_byref_val_0 *)&val, 0, sizeof(__Block_byref_val_0), 11};
    void(*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_val_0 *)&val, 570425344));

    ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
    return 0;
}

    这个 __block 变量 val 是怎样转换过来的呢？ 我们发现，它竟然变为了结构体实例。 _block 变量也同 Block —样变成 __Block_byref_val_0 结构体类型的自动变量，即栈上生成的 __Block_byref_val_0 结构体实例。该变量初始值为11 这个值也出现在结构体实例的初始化中，这意味着该结构体持有相当于原自动变量的成员变量。

    刚刚在 Block中 向静态变量赋值时，使用了指向该静态变量的指针。而向 block 变量賦值 要比这个更为复杂。Block 的 _main_block_impl_0 结构体实例持有指向 __block 变量的 __Block_byref_val_O 结构体实例的指针。__Block_byref_val_0 结构体实例的成员变量 __forwarding 持有指向该实例自身的指针。通过成员变量 __forwarding 访问成员变量 a。

访问__block变量

block 运行时

objc_retainBlock

通过断点调试可知，在程序中会调用 objc_retainBlock。

objc_retainBlock

在添加 objc_retainBlock 符号断点运行后，可以查看到 objc_retainBlock 在 libobjc.A.dylib 中, 并且调用 _Block_copy。

libobjc.A.dylib_objc_retainBlock

在通过 objc4 运行时库中可知，objc_retainBlock 函数实际上就是 _Block_copy 函数。

id objc_retainBlock(id x) {
    return (id)_Block_copy(x);
}

在添加 _Block_copy 符号断点运行后，可以查看到 _Block_copy 在 libsystem_blocks.dylib 中。

libsystem_blocks.dylib_Block_copy

我们通过apple-oss-distributions 搜索可以找到 _Block_copy 所在的源码仓库libclosure。

Block_layout

我们先跳过 Block_copy的详细探索，通过查看 _Block_copy 的源码实现，可以发现 block 在底层的真正类型是 Block_layout 结构体。

struct Block_layout {
    //指向表明block类型的类
    void * __ptrauth_objc_isa_pointer isa;
    //用来作标识符的，类似于isa中的位域,按bit位表示一些block的附加信息
    volatile int32_t flags; // contains ref count
    //保留信息，可以理解预留位置，用于存储block内部变量信息
    int32_t reserved;
    //函数指针，指向具体的block实现的调用地址
    BlockInvokeFunction invoke;
    //block的附加信息
    struct Block_descriptor_1 *descriptor;
    // imported variables
};

Block_layout 结构体 类似于上面的 __block_impl 结构体。

• isa
  指向表明 block 类型的类

• flags
  标志位，类似于 isa 中的位域,按 bit 位表示一些 block 的附加信息，其中

     // Values for Block_layout->flags to describe block objects
  enum {
      BLOCK_DEALLOCATING =      (0x0001),  // runtime
      BLOCK_REFCOUNT_MASK =     (0xfffe),  // runtime
      BLOCK_INLINE_LAYOUT_STRING = (1 << 21), // compiler
  
  #if BLOCK_SMALL_DESCRIPTOR_SUPPORTED
      BLOCK_SMALL_DESCRIPTOR =  (1 << 22), // compiler
  #endif
  
      BLOCK_IS_NOESCAPE =       (1 << 23), // compiler
      BLOCK_NEEDS_FREE =        (1 << 24), // runtime
      BLOCK_HAS_COPY_DISPOSE =  (1 << 25), // compiler //是否有 Block_descriptor_2 
      BLOCK_HAS_CTOR =          (1 << 26), // compiler: helpers have C++ code
      BLOCK_IS_GC =             (1 << 27), // runtime
      BLOCK_IS_GLOBAL =         (1 << 28), // compiler //是否是全局block
      BLOCK_USE_STRET =         (1 << 29), // compiler: undefined if !BLOCK_HAS_SIGNATURE
      BLOCK_HAS_SIGNATURE  =    (1 << 30), // compiler //是否有签名，是否有 Block_descriptor_3
      BLOCK_HAS_EXTENDED_LAYOUT=(1 << 31)  // compiler
  };
  

• reserved
  保留信息，可以理解预留位置，猜测是用于存储 block 内部变量信息

• invoke
  是一个函数指针，指向 block 的执行代码

• descriptor
  block 的附加信息，比如保留变量数、block的大小、进行 copy 或 dispose 的辅助函数指针。有三类：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大小
  };
  
  # define BLOCK_DESCRIPTOR_2 1
  
  struct Block_descriptor_2 {
      // requires BLOCK_HAS_COPY_DISPOSE
      BlockCopyFunction copy;//拷贝函数指针
      BlockDisposeFunction dispose;
  };
  
  # 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;//默认打印
  }
  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;
  }
  
  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);//descriptor_1的地址
      if (aBlock->flags & BLOCK_HAS_COPY_DISPOSE) {
          desc += sizeof(struct Block_descriptor_2); //descriptor_2的地址
      }
      return (struct Block_descriptor_3 *)desc;
  }
  

Block 内存变化

通过前面的 Block 类型内容可以得知下面这段代码中 block1 为 NSMallocBlock

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

添加符号断点 objc_retainBlock 调试，会发现输出为 NSStackBlock

objc_retainBlock 调用时为NSStackBlock

当走到符号断点 _Block_copy return时，输出结果为 NSMallocBlock，地址发生改变输出 NSMallocBlock

_Block_copy 函数 Return 时为 NSMallocBlock

根据 Block_Layout 结构体声明源码中，可以发现BlockInvokeFunction invoke，即 block 的执行者，是从 isa 的首地址平移 16字节取到invoke，然后进行调用执行的。

Block 的 签名 Signature

通过 po [NSMethodSignature signatureWithObjCTypes:"v8@?0"] ，打印签名，如下图

block的Signature
通过上图可知，block 的签名信息类似于方法的签名信息，主要是体现 block 的返回值，参数以及类型等信息。

_Block_copy

_Block_copy做了什么？

// Copy, or bump refcount, of a block.  If really copying, call the copy helper if present.
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;
    //是否需要释放
    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 {

        // Its a stack block.  Make a copy.
        size_t size = Block_size(aBlock);
        struct Block_layout *result = (struct Block_layout *)malloc(size);
        if (!result) return NULL;
        memmove(result, aBlock, size); // bitcopy first
#if __has_feature(ptrauth_calls)
        // Resign the invoke pointer as it uses address authentication.
        result->invoke = aBlock->invoke;

#if __has_feature(ptrauth_signed_block_descriptors)
        if (aBlock->flags & BLOCK_SMALL_DESCRIPTOR) {
            uintptr_t oldDesc = ptrauth_blend_discriminator(
                    &aBlock->descriptor,
                    _Block_descriptor_ptrauth_discriminator);
            uintptr_t newDesc = ptrauth_blend_discriminator(
                    &result->descriptor,
                    _Block_descriptor_ptrauth_discriminator);

            result->descriptor =
                    ptrauth_auth_and_resign(aBlock->descriptor,
                                            ptrauth_key_asda, oldDesc,
                                            ptrauth_key_asda, newDesc);
        }
#endif
#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;
        return result;
    }
}

_Block_copy 代码的执行顺序如下：

1. 如果需要释放，如果需要则直接释放

2. 如果是 BLOCK_IS_GLOBAL , 全局 Block -- 不需要 copy ，直接返回

3. 反之，只有两种情况：StackBlock or MallocBlock，由于 MallocBlock 需要申请空间，前面并没有申请空间的相关代码，所以只能是StackBlock。

4. 通过 malloc 申请内存空间用于接收 block

5. 通过 memmove 将 block 拷贝至新申请的内存中

6. 设置 block 对象的类型为 NSMallocBlock ，即 result->isa = _NSConcreteMallocBlock

__Block_copy的意义？

    在全局变量上的 block，从变量作用域外也可以通过指针安全地使用。但设置在栈上的 block ，所在的变量作用域结束，该 block 就会被废弃。因此， Block 提供了将 block 从栈上赋值到堆上的方法来解决，即使 Block 语法记述的变量作用域结束，堆上的 block 还可以继续存在。也就是 result->isa = _NSConcreteMallocBlock，验证了 Block 内存变化 中 _Block_copy函数执行完成后，对象类型的变化。

Block 的类	副本源的配置存储域	复制效果
_NSConcreteStackBlock	栈	从栈复制到堆
_NSConcreteGlobalBlock	程序的数据区域	什么也不做
_NSConcreteStackBlock	堆	引用计数增加

Block 是如何处理变量的?

我们在之前使用 __block标识符 生成的 cpp 源码中可以发现 __main_block_desc_0中多出 copy函数指针 和 dispose函数指针，最终对应到 _Block_object_assign 函数和 _Block_object_dispose 函数。
在 libclosure 源码中，我们可以搜索到相应的函数实现，其中代码需要根据下面参数知道外部变量的种类

// 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

void _Block_object_assign(void *destArg, const void *object, const int flags) {
    const void **dest = (const void **)destArg;
    switch (os_assumes(flags & BLOCK_ALL_COPY_DISPOSE_FLAGS)) {
      case BLOCK_FIELD_IS_OBJECT:
        /*******
        id object = ...;
        [^{ object; } copy];
        ********/

        _Block_retain_object(object);
        *dest = object;
        break;

      case BLOCK_FIELD_IS_BLOCK:
        /*******
        void (^object)(void) = ...;
        [^{ object; } copy];
        ********/

        *dest = _Block_copy(object);
        break;
    
      case BLOCK_FIELD_IS_BYREF | BLOCK_FIELD_IS_WEAK:
      case BLOCK_FIELD_IS_BYREF:
        /*******
         // copy the onstack __block container to the heap
         // Note this __weak is old GC-weak/MRC-unretained.
         // ARC-style __weak is handled by the copy helper directly.
         __block ... x;
         __weak __block ... x;
         [^{ x; } copy];
         ********/

        *dest = _Block_byref_copy(object);
        break;
        
      case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_OBJECT:
      case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_BLOCK:
        /*******
         // copy the actual field held in the __block container
         // Note this is MRC unretained __block only. 
         // ARC retained __block is handled by the copy helper directly.
         __block id object;
         __block void (^object)(void);
         [^{ object; } copy];
         ********/

        *dest = object;
        break;

      case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_OBJECT | BLOCK_FIELD_IS_WEAK:
      case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_BLOCK  | BLOCK_FIELD_IS_WEAK:
        /*******
         // copy the actual field held in the __block container
         // Note this __weak is old GC-weak/MRC-unretained.
         // ARC-style __weak is handled by the copy helper directly.
         __weak __block id object;
         __weak __block void (^object)(void);
         [^{ object; } copy];
         ********/

        *dest = object;
        break;

      default:
        break;
    }
}

_Block_object_assign 将变量赋值在对象类型的结构体成员变量中:

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

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

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

_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;
}

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

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

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

4. 栈上的 __block 变量用结构体实例在 __block 变量从栈复制到堆上时，会将 __forwarding 的值替换为复制目标堆上的 __block 变量用结构体实例的地址。
   

   复制_block变量

   通过 __block 变量的复制，__block 变量用结构体成员变量 __forwarding 可以实现无论 __block变量配置在栈上还是堆上时都能够正确地访问 __block 变量。

5. Block 从栈复制到堆时对 __block 变量产生的影响整理为下表：

   __block 变量的配置存储域	Block 从栈赋值到堆时的影响
   栈	从栈复制到堆并被 Block 持有
   堆	被 Block 持有

_Block_object_dispose

在 Block 变量即将被丢弃时，会调用 _Block_object_dispose 函数对变量进行释放，类似于 release。

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:
        // get rid of the __block data structure held in a Block
        _Block_byref_release(object);
        break;
      case BLOCK_FIELD_IS_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 循环引用的解决方式

如果在 Block 使用中，类对象 self 持有 Block ，Block 中使用 id 类型变量 self，就会造成循环引用。

使用Block成员变量循环引用

weak-strong-dance

• 如果 block 内部并未嵌套 block，直接使用__weak修饰 self 即可,此时的 weakSelf 和 self 指向同一片内存空间，且使用 __weak 不会强持有，导致 self 的引用计数发生变化，

  //...
  @property (nonatomic, copy) void(^block)(void);
  @property (nonatomic, copy) NSString *name;
  //...
  self.name = @"block";
   __weak typeof(self) weakSelf = self;
  self.block = ^(void){
      NSLog(@"%@",weakSelf.name);
  };
  self.block();
  

• 如果 block 内部嵌套 block ，需要同时使用 __weak 和 __strong，由于仅使用 weakSelf没有强引用，会导致 weakSelf 被释放，因此使用 strongSelf 在 block 内部对其进行强引用。其中 strongSelf 是一个临时变量，在 block 的作用域内，即内部 block 执行完就释放 strongSelf。这种方式属于打破 self 对 block 的强引用，依赖于中介者模式，自动置为nil，即自动释放。

  //...
  @property (nonatomic, copy) void(^block)(void);
  @property (nonatomic, copy) NSString *name;
  //...
  self.name = @"block";
   __weak typeof(self) weakSelf = self;
  self.block = ^(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.block();
  

  使用Block成员变量避免循环引用

__block 修饰符

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

//...
@property (nonatomic, copy) void(^block)(void);
@property (nonatomic, copy) NSString *name;
//...
self.name = @"block";
 __block ViewController *vc = self;
self.block = ^(void){
   
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
            NSLog(@"%@",vc.name);
            vc = nil;
     });
}; 
self.block();

需要注意的是 __block 修饰的变量需要手动指向 nil，并且调用 block，否则也会造成循环引用。

使用__block造成的循环引用

block 参数

需要传递的对象作为 block 参数，提供给 block 内部使用，不会造成循环引用。

//...
@property (nonatomic, copy) void(^block)(void);
@property (nonatomic, copy) NSString *name;
//...
self.name = @"block";
self.block = ^(ViewController *vc){
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"%@",vc.name);
        
    });
};
self.block(self);