iOS-底层原理 30:Block底层原理

iOS 底层原理 文章汇总

本文主要介绍block的类型、循环引用的解决方法以及block底层的分析

block 类型

block主要有三种类型

  • __NSGlobalBlock__:全局block,存储在全局区
void(^block)(void) = ^{
    NSLog(@"CJL");
};
NSLog(@"%@", block);

此时的block无参也无返回值,属于全局block


image
  • __NSMallocBlock__:堆区block,因为block既是函数,也是对象
int a = 10;
void(^block)(void) = ^{
    NSLog(@"CJL - %d", a);
};
NSLog(@"%@", block);

此时的block会访问外界变量,即底层拷贝a,所以是堆区block


image
  • __NSStackBlock__:栈区block
 int a = 10;
void(^block)(void) = ^{
    NSLog(@"CJL - %d", a);
};
NSLog(@"%@", ^{
    NSLog(@"CJL - %d", a);
});

其中局部变量a在没有处理之前(即没有拷贝之前)是 栈区block, 处理后(即拷贝之后)是堆区block ,目前的栈区block越来越少了

image

这个情况下,可以通过__weak不进行强持有,block就还是栈区block

image

总结

  • block直接存储在全局区

  • 如果block访问外界变量,并进行block相应拷贝,即copy

    • 如果此时的block是强引用,则block存储在堆区,即堆区block

    • 如果此时的block通过__weak变成了弱引用,则block存储在栈区,即栈区block

Block循环引用

  • 正常释放:是指A持有B的引用,当A调用dealloc方法,给B发送release信号,B收到release信号,如果此时B的retainCount(即引用计数)为0时,则调用B的dealloc方法

  • 循环引用:A、B相互持有,所以导致A无法调用dealloc方法给B发送release信号,而B也无法接收到release信号。所以A、B此时都无法释放

如下图所示


image

解决循环引用

请问下面两段代码有循环引用吗?

//代码一
NSString *name = @"CJL";
self.block = ^(void){
    NSLog(@"%@",self.name);
};
self.block();

//代码二
UIView animateWithDuration:1 animations:^{
    NSLog(@"%@",self.name);
};

代码一种发生了循环引用,因为在block内部使用了外部变量name,导致block持有了self,而self原本是持有block的,所以导致了self和block的相互持有。代码二中无循环引用,虽然也使用了外部变量,但是self并没有持有animation的bblock,仅仅只有animation持有self,不构成相互持有

解决循环引用常见的方式有以下几种;

  • 【方式一】weak-strong-dance

  • 【方式二】__block修饰对象(需要注意的是在block内部需要置空对象,而且block必须调用

  • 【方式三】传递对象self作为block的参数,提供给block内部使用

  • 【方式四】使用NSProxy

方式一:weak-stong-dance

  • 如果block内部并未嵌套block,直接使用__weak修饰self即可
typedef void(^CJLBlock)(void);

@property(nonatomic, copy) CJLBlock cjlBlock;

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

此时的weakSelfself 指向同一片内存空间,且使用__weak不会导致self的引用计数发生变化,可以通过打印weakSelf和self的指针地址,以及self的引用计数来验证,如下所示

image

  • 如果block内部嵌套block,需要同时使用__weak__strong
__weak typeof(self) weakSelf = self;
self.cjlBlock = ^(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.cjlBlock();

其中strongSelf是一个临时变量,在cjlBlock的作用域内,即内部block执行完就释放strongSelf

这种方式属于打破self对block的强引用,依赖于中介者模式,属于自动置为nil,即自动释放

方式二:__block修饰变量

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

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

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

方式三:对象self作为参数

主要是将对象self作为参数,提供给block内部使用,不会有引用计数问题

typedef void(^CJLBlock)(ViewController *);

@property(nonatomic, copy) CJLBlock cjlBlock;

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

下面介绍循环引用的第4种方式,即使用NSProxy虚拟类

NSProxy 虚拟类

  • OC是只能单继承的语言,但是它是基于运行时的机制,所以可以通过NSProxy来实现 伪多继承,填补了多继承的空白

  • NSProxyNSObject是同级的一个类,也可以说是一个虚拟类,只是实现了NSObject的协议

  • NSProxy 其实是一个消息重定向封装的一个抽象类,类似一个代理人,中间件,可以通过继承它,并重写下面两个方法来实现消息转发到另一个实例

- (void)forwardInvocation:(NSInvocation *)invocation;
- (nullable NSMethodSignature *)methodSignatureForSelector:(SEL)sel

使用场景

NSProxy的使用场景主要有两种

  • 实现多继承功能
  • 解决了NSTimer&CADisplayLink创建时对self强引用问题,参考YYKitYYWeakProxy

循环引用解决原理

主要是通过自定义的NSProxy类的对象来代替self,并使用方法实现消息转发

下面是NSProxy子类的实现以及使用的场景

  • 自定义一个NSProxy的子类CJLProxy
@interface CJLProxy : NSProxy

- (id)transformObjc:(NSObject *)objc;

+ (instancetype)proxyWithObjc:(id)objc;

@end

@interface CJLProxy ()

@property(nonatomic, weak, readonly) NSObject *objc;

@end

@implementation CJLProxy

- (id)transformObjc:(NSObject *)objc{
   _objc = objc;
    return self;
}

+ (instancetype)proxyWithObjc:(id)objc{
    return  [[self alloc] transformObjc:objc];
}



//2.有了方法签名之后就会调用方法实现
- (void)forwardInvocation:(NSInvocation *)invocation{
    SEL sel = [invocation selector];
    if ([self.objc respondsToSelector:sel]) {
        [invocation invokeWithTarget:self.objc];
    }
}

//1、查询该方法的方法签名
- (NSMethodSignature *)methodSignatureForSelector:(SEL)sel{
    NSMethodSignature *signature;
    if (self.objc) {
        signature = [self.objc methodSignatureForSelector:sel];
    }else{
        signature = [super methodSignatureForSelector:sel];
    }
    return signature;
}

- (BOOL)respondsToSelector:(SEL)aSelector{
    return [self.objc respondsToSelector:aSelector];
}

@end
  • 自定义Cat类和Dog
//********Cat类********
@interface Cat : NSObject
@end

@implementation Cat
- (void)eat{
   NSLog(@"猫吃鱼");
}
@end

//********Dog类********
@interface Dog : NSObject
@end

@implementation Dog
- (void)shut{
    NSLog(@"狗叫");
}
@end
  • 通过CJLProxy实现多继承功能
- (void)cjl_proxyTest{
    Dog *dog = [[Dog alloc] init];
    Cat *cat = [[Cat alloc] init];
    CJLProxy *proxy = [CJLProxy alloc];
    
    [proxy transformObjc:cat];
    [proxy performSelector:@selector(eat)];
    
    [proxy transformObjc:dog];
    [proxy performSelector:@selector(shut)];
}
  • 通过CJLProxy解决定时器中self的强引用问题
self.timer = [NSTimer timerWithTimeInterval:1 target:[CJLProxy proxyWithObjc:self] selector:@selector(print) userInfo:nil repeats:YES];
    [[NSRunLoop currentRunLoop] addTimer:self.timer forMode:NSRunLoopCommonModes];

总结

循环应用的解决方式从根本上来说就两种,以self -> block -> self为例

  • 打破self 对 block的强引用,可以block属性修饰符使用weak,但是这样会导致block还每创建完就释放了,所以从这里打破强引用行不通

  • 打破block对self的强引用,主要就是self的作用域和block作用域的通讯,通讯有代理、传值、通知、传参等几种方式,用于解决循环,常见的解决方式如下:

    • weak-strong-dance

    • __block(block内对象置空,且调用block)

    • 将对象self作为block的参数

    • 通过NSProxy的子类代替self

Block 底层分析

主要是通过clang、断点调试等方式分析Block底层

本质

  • 定义block.c文件
#include "stdio.h"

int main(){

    void(^block)(void) = ^{
        printf("CJL");
    };
    return 0;
}
  • 通过xcrun -sdk iphonesimulator clang -arch x86_64 -rewrite-objc block.c,将block.c 编译成 block.cpp,其中block在底层被编译成了以下的形式
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("CJL");
}

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

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

相当于block等于__main_block_impl_0,是一个函数

  • 查看__main_block_impl_0,是一个结构体,同时可以说明block是一个__main_block_impl_0类型的对象,这也是为什么block能够%@打印的原因
//**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;
};

总结block本质对象、函数、结构体,由于block函数没有名称,也被称为匿名函数

block通过clang编译后的源码间的关系如下所示,以__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("CJL - %d", a);
    };
    
     block();
    return 0;
}
  • 底层编译成下面这样
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("CJL - %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);
    return 0;
}

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

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

__block的原理

  • a加一个__block,然后在block中对a进行++操作
int main(){

    __block int a = 11;
    void(^block)(void) = ^{
        a++;
        printf("CJL - %d", a);
    };
    
     block();
    return 0;
}
  • 底层编译为如下
    • main中的a是通过外界变量封装的对象

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

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

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("CJL - %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;
}

总结

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

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

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

两种拷贝对比如下

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

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

block底层真正类型

分析block源码所在位置

  • 通过在block处打断点,分析运行时的block


    image
  • objc_retainBlock 符号断点,发现会走到_Block_copy

    image

  • _Block_copy符号断点,运行断住,在libsystem_blocks.dylib源码中

    image

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

Block真正类型

查看Block_layout类型的定义,是一个结构体

// CJL注释: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的附加信息,类似于isa中的位域,其中flags的种类有以下几种,主要重点关注BLOCK_HAS_COPY_DISPOSEBLOCK_HAS_SIGNATUREBLOCK_HAS_COPY_DISPOSE 决定是否有 Block_descriptor_2BLOCK_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 时动态调用。

// CJL注释: 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
};
  • reserved:保留信息,可以理解预留位置,猜测是用于存储block内部变量信息

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

  • descriptor:block的附加信息,比如保留变量数、block的大小、进行copy或dispose的辅助函数指针。有三类

    • Block_descriptor_1是必选的
    • Block_descriptor_2Block_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_2Block_descriptor_3都是通过Block_descriptor_1的地址,经过内存平移得到的

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

// CJL注释: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;
}

// CJL注释: 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;
}

内存变化

  • 打断点运行,走到objc_retainBlock,block断点处读取寄存器x0,此时的block全局block ,即__NSGlobalBlock__类型

    image

  • 增加外部变量a,并在block内打印

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

此时读取block断点处的x0 -- 栈block -- __NSStackBlock__

image

  • 执行到符号断点objc_retainBlock时,还是栈区block

    image

  • 增加_Block_copy符号断点并断住,直接在最后的ret加断点,读取x0,发现经过_Block_copy之后,变成了 堆block,即__NSMallocBlock__,主要是因为block地址发生了改变,为堆block

    image

调用情况

  • 同样也可以通过断点来验证


    image
    • register read x0 读取x0,为堆block

    • register read x9 读取x9
      [站外图片上传中...(image-b14a19-1605377133592)]

    • register read x11 ,此时是指向一片内存空间,用于存储_block_invoke

      image

  • 按住control + step into,进入 _block_invoke,可以得出是通过内存平移得到的block内部实现

    image

    前面提到的Block_layout的结构体源码,从源码中可以看出,有个属性invoke,即block的执行者,是从isa的首地址平移 16字节取到invoke,然后进行调用执行的

签名

  • 继续操作,读取x0寄存器,看内存布局,通过 内存平移 3*8 就可获得Block_layout的属性descriptor,主要是为了查看是否有Block_descriptor_2Block_descriptor_3,其中3中有block的签名

    • register read x0,读取寄存器x0
    • po 0x00000002828a2160 , 打印block
    • x/8gx 0x00000002828a2160 ,即打印block内存情况
      image
    • x/8gx 0x00000001008a0010 , 查看descriptor的内存情况,其中第三个0x000000010089f395表示签名
      image
  • 判断是否有Block_descriptor_2,即flags的BLOCK_HAS_COPY_DISPOSE(拷贝辅助函数)是否有值

    • p/x 1<<25 ,即1左移25位,其十六进制为0x2000000
    • p 0x02000000 & 0x00000000c1000002 ,即BLOCK_HAS_COPY_DISPOSE & flags ,等于0,表示没有Block_descriptor_2
      image
  • 判断是否有Block_descriptor_3

    • p/x 1<<30,即1左移30位
    • p 0x40000000 & 0x00000000c1000002 ,即BLOCK_HAS_SIGNATURE & flags ,有值,说明有Block_descriptor_3
      image
    • p (char *)0x000000010089f395 -- 获取Block_descriptor_3中的属性signature签名
      image
    • po [NSMethodSignature signatureWithObjCTypes:"v8@?0"] ,即打印签名
      image

其中签名的部分说明如下

//无返回值
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三次copy分析

_Block_copy源码分析

  • 进入_Block_copy源码,将block 从栈区拷贝至堆区
    • 如果需要释放,如果需要则直接释放

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

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

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

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

      • 设置block对象的类型为堆区block,即result->isa = _NSConcreteMallocBlock

// Copy, or bump refcount, of a block.  If really copying, call the copy helper if present.
// CJL重点提示: 这里是核心重点 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_object_assign 分析

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

// CJL注释: 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 *cjl_name = [NSString stringWithFormat:@"CJL"];
void (^block1)(void) = ^{ // block_copy
    lg_name = @"CJL";
    NSLog(@"CJL - %@",lg_name);
    
    // block 内存
};
block1();
  • xcrun编译结果如下,
    • 编译后的cjl_name比普通变量多了__Block_byref_id_object_copy_131__Block_byref_id_object_dispose_131

    • __Block_byref_cjl_name_0结构体中多了__Block_byref_id_object_copy__Block_byref_id_object_dispose

//********编译后的cjl_name********
 __Block_byref_cjl_name_0 cjl_name =
        {(void*)0,
            (__Block_byref_cjl_name_0 *)&cjl_name,
            33554432,
            sizeof(__Block_byref_cjl_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_cjl_name_0结构体********
struct __Block_byref_cjl_name_0 {
  void *__isa;
__Block_byref_cjl_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 *cjl_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是如何取到 cjl_name的?

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

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

  • 3、发现外部变量还存有一个对象,从bref中取出相应对象cjl_name,拷贝至block空间,才能使用(相同空间才能使用,不同则不能使用)。最后通过内存平移就得到了cjl_name,此时的cjl_name 和 外界的cjl_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的流程如下图所示


三层copy流程

推荐阅读更多精彩内容