23、block

一、Block循环引用

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

循环引用:A、B 相互持有

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

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

代码一 中发送了循环引用,因为在block 内部使用了外部变量 name,导致block持有了self,而self 原本是持有block的 ,所以导致了elf 和 block 的相互持有。

代码二 中 无循环引用,虽然也使用了外部变量,但是 self 并没有持有animation 的block ,仅仅只是animation 持有 self,不构成相互持有

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

1、weak-strong-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);
}

此时的weakself 和 self 指向同一片内存空间,且使用__weak 不会导致self的引用计数发生变化,可以通过打印weakSelf 和 self 的指针地址。

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

__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();

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

2、__block 修饰对象 (需要注意的是在block内部需要置空对象,而且block 必须调用)

这种方式 同样依赖于 中介者模式,属于手动释放,是通过__block 修饰对象,主要是因为__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 必须调用,如果不调用 block,vc 就不会置空,那么依旧是循环引用,self 和block 都不会被释放

3、传递对象self 作为 block的参数,提供给block内部使用

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

typedef void(^CBlock)(ViewController *);

@property(nonatomic, copy) CBlock 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);
4、 使用 NSproxy
  • OC 只是 单继承 的语言,但是 它是基于 运行时的机制,所以可以通过NSproxy 来实现 假的多继承,填补了多继承的空白

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

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

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

使用场景:

NSProxy 的使用场景主要有两种:

1、实现 多继承 场景
2、解决 NStimer & CADisplayLink 创建时 对self 强引用 问题

循环引用解决原理:
主要是通过自定义的NSProxy 类的对象来代替 self ,并使用方法实现消息转发

自定义一个 NSProxy 的子类 CProxy

@interface CProxy : NSProxy

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

+ (instancetype)proxyWithObjc:(id)objc;

@end

@interface CProxy ()

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

@end

@implementation CProxy

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

通过CProxy 解决 定时器中 self 的强引用问题

self.timer = [NSTimer timerWithTimeInterval:1 target:[CJLProxy proxyWithObjc:self] selector:@selector(print) userInfo:nil repeats:YES];
    [[NSRunLoop currentRunLoop] addTimer:self.timer forMode:NSRunLoopCommonModes];

** 通过CProxy 实现 多继承 功能**

- (void)proxyTest{
    Dog *dog = [[Dog alloc] init];
    Cat *cat = [[Cat alloc] init];
    CProxy *proxy = [CProxy alloc];
    
    [proxy transformObjc:cat];
    [proxy performSelector:@selector(eat)];
    
    [proxy transformObjc:dog];
    [proxy performSelector:@selector(shut)];
}

二、block 类型

block 主要有三种类型:

NSGlobalBlockNSMallocBlockNSStackBlock

1、 NSGlobalBlock 全局block ,存储在全局区

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

2、NSMallocBlock 堆区block , 如下:block 既是函数,也是对象

int a = 10;
void(^block)(void) = ^{
    NSLog(@"XXX - %d", a);
};
NSLog(@"%@", block); 
//此时的block会访问外界变量,即底层拷贝a,所以是堆区block

3、NSStackBlock 栈区block

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

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

小结:

1、block 直接存储在全局区

2、如果block 访问外界变量,并进行block 相应拷贝(copy),如果此时的block是强引用,则block 存储在堆区;如果此时的block 通过__weak变成了弱引用,则block 存储在栈区中

三、block 底层分析

通过 clang ,断点调试分析Block 底层

本质分析
#include "stdio.h"
int main(){
    void(^block)(void) = ^{
        printf("XXX");
    };
    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("XXX");
}

//******简化******
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 函数没有名称,也称为 匿名函数

image.png
1、 block 为什么需要调用?

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

  • 函数声明:即block 内部实现声明成一个函数__main_block_func_0
  • 执行具体的函数实现:通过调用 block 的FunPtr 指针,调用block 执行
2、 block 如何获取外界变量的?
int main(){
    int a = 11;
    void(^block)(void) = ^{
        printf("XXX - %d", a);
    };
     block();
    return 0;
}

clang编译后

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("XXX - %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("XXX - %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("XXX - %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底层分析类型

可以通过苹果开源网站下载的libclosure-74 源码,会发现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 的附加信息,类似于isa 中的位域,其中flags 的种类有以下几种,主要重点关注:

BLOCK_HAS_COPY_DISPOSE 决定是否有 Block_descriptor_2

BLOCK_HAS_SIGNATURE 决定是否有Block_descriptor_3

第1位 - block_deallocating,释放标记,一般常用Block_needs_free 做 位与 操作,一同传入Flags,告知该block 可释放。

第16位 -block_refcount_max ,存储引用计数的值;是一个可选参数

第24位- Block_needs_free 低16是否有效的标志,程序根据它来决定是否增加或减少引用计数位的值

第25位 block_has_copy_dispose,是否拥有拷贝辅助函数

第26位 block_is_gc , 是否拥有block 析构函数

第27位 标志是否有垃圾回收

第28位 block _is_global ,标志是否是全局block

第30位 block_has_signture, 与block_use_stret相对,判断当前block 是否拥有一个签名。用于runtime 时 动态调用

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

// 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断点处读取寄存器xo,此时的block 是全局block ,即 NSGlobalBlock 类型
image.png
  • 增加外部变量a,并在block 内打印
int a = 10;
void (^block1)(void) = ^{
    NSLog(@"XXX - %d", a);
};
block1();

此时读取block 断点处的 xo -- 栈block -- NSStackBlock

image.png
  • 执行到符号断点 objc_retainBlock 时,还是在栈区block
image.png
  • 增加 _block_copy 符合断点并断往,直接在最后的ret加断点,读取xo,发现经过_block_copy之后,变成了 堆block ,即NSMallocBlock,主要是因为block 地址发生了改变,为堆block
image.png

调用情况

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

1、 register read xo 读取xo,为堆block

2、 register read x9 读取 x9

image.png

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

image.png

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

image.png

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

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

  • register read xo,读取寄存器 xo

  • po 0x00000002828a2160, 打印block

  • x/8gx 0x00000002828a2160,即打印block 内存情况

image.png
  • x/8gx 0x00000001008a0010,查看descriptor 的内存情况,其中第三个0x000000010089f395 表示签名
image.png
  • 判断是否有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.png
  • 判断是否有Block_descriptor_3

p/x 1<< 30 ,即1 左移 30 位

p 0x40000000 & 0x00000000c1000002 ,即 BLOCK_HAS_SIGNATURE & flags,有值,说明有 Block_descriptor_3

image.png

p (char *) 0x000000010089f395 获取block_descriptor_3 中的属性signature 签名


image.png

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

image.png

四、block 三次copy分析

1、_block_copy 源码分析,进入_block_copy源码,将block 从栈区拷贝奥堆区

如果需要就直接释放

如果是 globalBlock 不需要copy ,直接返回,反之只有两种情况:栈block 和 堆block ,由于堆block需要申请空间,前面并没有申请空间额相关代码,所以只能是 栈block

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

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

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

// Copy, or bump refcount, of a block.  If really copying, call the copy helper if present.
// XXX重点提示: 这里是核心重点 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_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_assgin 是在底层编译代码中,外部变量拷贝是调用的方法就是它

  • 进入_block_object_assign 源码

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

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

如果是_block修饰的变量,调用_block_byref_copy 函数 进行内存拷贝及常规处理

  • 进入 _block_byref_copy 源码

将传入对象,强转为 block_byref 结构体类型对象,保存一份。

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

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

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

三层copy总结

第一层:通过 _block_copy 实现对象的自身拷贝,从栈区拷贝到堆区

第二层:通过 _block_bref_copy 方法,将对象拷贝为Block_byref结构体类型

第三层:调用_block_object_assign 方法,对__block修饰的当前变量的拷贝

注:只有__block 修饰的对象,block的copy 才有三层

__Block_object_dispose 分析

release 与 retain 是一一对应的,__block_objct_object 其本质是retain ,所对应的还有一个release (__block_object_dispose方法)
源码如下:

// 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);//释放
        }
    }
}
image.png

推荐阅读更多精彩内容