14 - block的底层分析

2021-11-13 本文已影响0人 iOS之文一

OC底层原理探索文档汇总

上文说到，block本质是一个可以捕获变量的匿名函数，并且具有对象的特征，也可以看做是一个仅有一个函数的对象。接下来就通过Clang和查看源码分析block的底层实现来证明

主要内容：
1、block的本质
2、__block的原理
3、block的底层类型
4、block从栈拷贝到堆的过程分析

1、block的本质

1.1 block在底层的结构

定义block.c文件

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

通过Clang编译

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

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
        printf("wy");
}

//******简化******
void(*block)(void) = __main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA));//构造函数

block->FuncPtr(block);//block调用执行

说明：

可以看出__main_block_impl_0用来构造block
__main_block_impl_0函数传入两个参数，__main_block_func_0和&__main_block_desc_0_DATA。
通过指向block的FuncPtr方法进行调用

查看结构体

//**block定义结构体**
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;
  }
};

//**block实现结构体**
struct __block_impl {
  void *isa;
  int Flags;
  int Reserved;
  void *FuncPtr;
};

说明：

可以看到__main_block_impl_0结构体是用以定义block的一个结构体。包含block结构体、block描述信息，以及一个同名构造函数
- impl是block本身
- Desc会提供一些定义block时的描述信息
- 在构造函数中会将外界的值赋值到block结构体中。以此来构造block
- 重点看的就是给impl的isa赋值block类型，还有将外界的函数赋值给block。
在block结构体__block_impl中包含isa和FuncPtr，还有Flags和Reserved（这两个不用关注）
- 结构体中包含有isa，有三种类型，NSGlobalBlock、NSMallocBlock、NSStackBlock，这也可以说明block可以看做一个对象，因为它有isa，并且指向不同的结构体类型。
- FuncPtr就是block中的函数，它用来执行具体的功能

1.2 block如何捕获外界变量

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

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

底层编译：

//**block实现结构体**
struct __block_impl {
  void *isa;
  int Flags;
  int Reserved;
  void *FuncPtr;
};

//block定义结构体
struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int a;//编译时就自动生成了相应的变量
  // a(_a) 的做法是将传入的_a赋值给当前结构体中的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;
  }
};

//block函数
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  //在函数中会自动创建一个局部变量，并将外界的变量值赋值给局部变量a中
  //属于值拷贝，也就是直接将11赋值给a.因此__cself->a和a没有关系
  int a = __cself->a; // bound by copy 值拷贝，即 a = 11
  printf("WY - %d", a);
}
    
int main(){

    int a = 11;
    //当block使用外界变量时，会自动将变量传入到block中
    void(*block)(void) = __main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA, a));

     block)->FuncPtr(block);
    return 0;
}

说明：

当block使用外界的变量时，会将变量通过block的构造函数中传入到block定义结构体中
在block的构造函数中会将变量赋值给block定义结构体__main_block_impl_0的变量。（此时_main_block_impl_0结构体会自动创建一个相同名称的变量,差别在于没有前边没有）
之后在block函数中也会自动创建一个局部变量，同时将__main_block_impl_0结构体中的变量赋值给局部变量。以此让函数可以使用该变量。

总结：block在使用外界变量时，会在block定义结构体中定义一个变量来保存外界变量的值。这样就表现为捕获。

1.3 __block修饰变量的原理

对a加一个__block，然后在block中使用a

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

Clang编译：

//block实现结构体
struct __block_impl {
  void *isa;//可以看到包含有isa
  int Flags;
  int Reserved;
  void *FuncPtr;//函数指针
};

//__block修饰的变量结构体
struct __Block_byref_a_0 {
  void *__isa;
__Block_byref_a_0 *__forwarding;//这里是a的地址
 int __flags;
 int __size;
 int a;//最后可以找到结构中的变量a
};

//定义block的底层结构体
struct __main_block_impl_0 {
  struct __block_impl impl;//block结构体
  struct __main_block_desc_0* Desc;//描述符
  __Block_byref_a_0 *a; // 变量，在编译时就会将外界的数据获取到
    //构造函数，传入的fp就是block内部的函数
  __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;//这里是栈block
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

//block内部的函数实现，会传入block本身
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
    //将block的变量赋值给当前函数的局部变量。
    //但因为此处的a是指针，不是基本类型，所以指针赋值的修改是可以影响的。
    //在函数中是定义了一个变量a，如果是基本数据类型，进行赋值，那么就是局部变量，无法影响到外界的a
    __Block_byref_a_0 *a = __cself->a; // bound by ref
    
    //之后将结构体a的__forwarding结构体拿到，在拿到结构体中的变量a,之后进行操作
    //也就是说这里操作的不是局部变量本身，而是局部变量结构体的指针。
    (a->__forwarding->a)++;
    printf("LG_Cooci - %d",(a->__forwarding->a));
}

int main(){

    //__block修饰的变量
    __attribute__((__blocks__(byref))) __Block_byref_a_0 a = {(void*)0,(__Block_byref_a_0 *)&a, 0, sizeof(__Block_byref_a_0), 11};
    //block定义
    void(*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_a_0 *)&a, 570425344));
    //这里是调用，可以看到会将结构体__Block_byref_a_0作为变量传入到block中
    void(*block)(void) = __main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_a_0 *)&a, 570425344));
    return 0;
}

说明：

可以看到外界的变量使用__block修饰后，其实在底层会将该变量设置为结构体__Block_byref_a_0
- __Block_byref_a_0结构体主要包含两个值，一个是变量地址，一个是变量本身
block在使用变量时，也会传入__Block_byref_a_0结构体来使用，可以看到传入的其实就是a的地址&a。
__main_block_impl_0中也会主动创建一个变量block来存储外界变量的地址，通过a(_a->__forwarding)来进行赋值
最后在block内部函数__main_block_func_0中也自动创建一个__Block_byref_a_0局部变量用来存储外界变量的地址。
在函数中使用变量时，其实使用的是通过变量地址所指向的变量。

总结：

外界变量会生成__Block_byref_a_0结构体

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

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

简单来说就是将值拷贝转变为指针拷贝，所以就可以修改外界变量了。

2、block的底层类型

查看libclosure-74源码,通过查看_Block_copy的源码实现，发现block在底层的真正类型是Block_layout

block真正类型
查看Block_layout类型的定义，是一个结构体

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

说明：

isa：指向表明block类型的类
flags：标识符，按bit位表示一些block的附加信息，使用位域的方式存储，其中flags的种类有以下几种，主要重点关注BLOCK_HAS_COPY_DISPOSE 和 BLOCK_HAS_SIGNATURE。 BLOCK_HAS_COPY_DISPOSE 决定是否有 Block_descriptor_2。BLOCK_HAS_SIGNATURE 决定是否有 Block_descriptor_3
- 第1 位 - BLOCK_DEALLOCATING，释放标记，-般常用 BLOCK_NEEDS_FREE 做位与操作，一同传入 Flags ，告知该 block 可释放。
- 低16位 - BLOCK_REFCOUNT_MASK，存储引用计数的值;是一个可选用参数
- 第24位 - BLOCK_NEEDS_FREE，低16是否有效的标志，程序根据它来决定是否增加或是减少引用计数位的值;
- 第25位 - BLOCK_HAS_COPY_DISPOSE，是否拥有拷贝辅助函数(a copy helper function);
- 第26位 - BLOCK_IS_GC，是否拥有 block 析构函数;
- 第27位，标志是否有垃圾回收;//OS X
- 第28位 - BLOCK_IS_GLOBAL，标志是否是全局block;
- 第30位 - BLOCK_HAS_SIGNATURE，与 BLOCK_USE_STRET 相对，判断当前 block 是否拥有一个签名。用于 runtime 时动态调用。

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

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;//默认打印
}
#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;
}

4、block的拷贝过程

包括block本身从栈如何拷贝到堆中，捕获的外界局部变量如何拷贝到堆中两类。

4.1 _Block_copy源码分析

这里只有一次拷贝，即将栈block拷贝为堆block，如果不使用外界的局部变量，就只有这一层拷贝。

源码

// 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，因为初始创建的不可能是堆block，堆block必须是通过栈block拷贝的
此处将栈block拷贝为堆block
- 通过malloc申请内存空间用于接收block
- 通过memmove将block拷贝至新申请的内存中
- 设置block对象的类型为堆区block，即result->isa = _NSConcreteMallocBlock

4.2 _Block_object_assign 分析

如果block使用外部的局部变量，则会开始接下来的两层拷贝

首先需要知道外部变量的种类有哪些，下面这些其中用的最多的是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.
};

4.2.1 _Block_object_assign源码

// __block 变量
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];
        ********/
        // objc 指针地址 weakSelf (self)
            // arc
        _Block_retain_object(object);
            // 持有
            //持有了当前指针，就在这里，强引用
        *dest = object;
        break;

      case BLOCK_FIELD_IS_BLOCK:
        /*******
        void (^object)(void) = ...;
        [^{ object; } copy];
        ********/
            
            // block 被一个 block 捕获

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

说明：

如果是普通对象，则交给系统arc处理，并通过*dest = object拷贝对象指针，即引用计数+1，所以如果直接使用外界的对象，则该对象会引用计数+1不能释放，这也是循环引用出现的条件
如果是block类型的变量，则通过_Block_copy操作，将block从栈区拷贝到堆区
如果是__weak或__block修饰的变量，调用_Block_byref_copy函数，开始捕获变量

4.2.2 进入_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
        //1、先创建了一个需要捕获的变量的结构体
        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;
        
        //2、在这里将这个结构体的指针都指向这两个变量中，这样他们两个的修改都会改变这个内存数据
        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结构体类型对象
再创建一个需要捕获的变量的结构体，并且将原来的数据拷贝到这个结构体中
最后让src和copy两者的forwarding都指向copy，也就是他们指向同一个区域，这样就可以做到他们两个的修改都会改变这个内存数据

总结：

最初创建的需要捕获的变量的结构体是在栈中

之后这个结构体从栈中copy到堆中

最后将栈的指针指向堆中的结构体，堆中的结构体的指针指向自己。

14 - block的底层分析

1、block的本质

1.1 block在底层的结构

1.2 block如何捕获外界变量

1.3 __block修饰变量的原理

2、block的底层类型

4、block的拷贝过程

4.1 _Block_copy源码分析

4.2 _Block_object_assign 分析

4.2.1 _Block_object_assign源码

4.2.2 进入_Block_byref_copy源码

猜你喜欢

热点阅读