iOS 底層原理 文章匯總

本文主要介紹block的類(lèi)型、循環(huán)引用的解決方法以及block底層的分析

block 類(lèi)型

block主要有三種類(lèi)型

• __NSGlobalBlock__：全局block，存儲(chǔ)在全局區(qū)

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

此時(shí)的block無(wú)參也無(wú)返回值，屬于全局block

image

• __NSMallocBlock__：堆區(qū)block，因?yàn)閎lock既是函數(shù)，也是對(duì)象

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

此時(shí)的block會(huì)訪問(wèn)外界變量，即底層拷貝a，所以是堆區(qū)block

image

• __NSStackBlock__：棧區(qū)block

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

其中局部變量a在沒(méi)有處理之前（即沒(méi)有拷貝之前）是 棧區(qū)block， 處理后（即拷貝之后）是堆區(qū)block ，目前的棧區(qū)block越來(lái)越少了

image

這個(gè)情況下，可以通過(guò)__weak不進(jìn)行強(qiáng)持有，block就還是棧區(qū)block

image

總結(jié)

• block直接存儲(chǔ)在全局區(qū)

• 如果block訪問(wèn)外界變量，并進(jìn)行block相應(yīng)拷貝，即copy

  • 如果此時(shí)的block是強(qiáng)引用，則block存儲(chǔ)在堆區(qū)，即堆區(qū)block

  • 如果此時(shí)的block通過(guò)__weak變成了弱引用，則block存儲(chǔ)在棧區(qū)，即棧區(qū)block

Block循環(huán)引用

• 正常釋放：是指A持有B的引用，當(dāng)A調(diào)用dealloc方法，給B發(fā)送release信號(hào)，B收到release信號(hào)，如果此時(shí)B的retainCount（即引用計(jì)數(shù)）為0時(shí)，則調(diào)用B的dealloc方法

• 循環(huán)引用：A、B相互持有，所以導(dǎo)致A無(wú)法調(diào)用dealloc方法給B發(fā)送release信號(hào)，而B(niǎo)也無(wú)法接收到release信號(hào)。所以A、B此時(shí)都無(wú)法釋放

如下圖所示

image

解決循環(huán)引用

請(qǐng)問(wèn)下面兩段代碼有循環(huán)引用嗎？

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

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

代碼一種發(fā)生了循環(huán)引用，因?yàn)樵?code>block內(nèi)部使用了外部變量name，導(dǎo)致block持有了self，而self原本是持有block的，所以導(dǎo)致了self和block的相互持有。代碼二中無(wú)循環(huán)引用，雖然也使用了外部變量，但是self并沒(méi)有持有animation的bblock，僅僅只有animation持有self，不構(gòu)成相互持有

解決循環(huán)引用常見(jiàn)的方式有以下幾種;

• 【方式一】weak-strong-dance

• 【方式二】__block修飾對(duì)象（需要注意的是在block內(nèi)部需要置空對(duì)象，而且block必須調(diào)用）

• 【方式三】傳遞對(duì)象self作為block的參數(shù)，提供給block內(nèi)部使用

• 【方式四】使用NSProxy

方式一：weak-stong-dance

• 如果block內(nèi)部并未嵌套block，直接使用__weak修飾self即可

typedef void(^CJLBlock)(void);

@property(nonatomic, copy) CJLBlock cjlBlock;

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

此時(shí)的weakSelf 和 self 指向同一片內(nèi)存空間，且使用__weak不會(huì)導(dǎo)致self的引用計(jì)數(shù)發(fā)生變化，可以通過(guò)打印weakSelf和self的指針地址，以及self的引用計(jì)數(shù)來(lái)驗(yàn)證，如下所示

image

• 如果block內(nèi)部嵌套block，需要同時(shí)使用__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是一個(gè)臨時(shí)變量，在cjlBlock的作用域內(nèi)，即內(nèi)部block執(zhí)行完就釋放strongSelf

這種方式屬于打破self對(duì)block的強(qiáng)引用，依賴于中介者模式，屬于自動(dòng)置為nil，即自動(dòng)釋放

方式二：__block修飾變量

這種方式同樣依賴于中介者模式，屬于手動(dòng)釋放，是通過(guò)__block修飾對(duì)象，主要是因?yàn)開(kāi)_block修飾的對(duì)象是可以改變的

__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;//手動(dòng)釋放
    });
};
self.cjlBlock();

需要注意的是這里的block必須調(diào)用，如果不調(diào)用block，vc就不會(huì)置空，那么依舊是循環(huán)引用，self和block都不會(huì)被釋放

方式三：對(duì)象self作為參數(shù)

主要是將對(duì)象self作為參數(shù)，提供給block內(nèi)部使用，不會(huì)有引用計(jì)數(shù)問(wèn)題

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

下面介紹循環(huán)引用的第4種方式，即使用NSProxy虛擬類(lèi)

NSProxy 虛擬類(lèi)

• OC是只能單繼承的語(yǔ)言，但是它是基于運(yùn)行時(shí)的機(jī)制，所以可以通過(guò)NSProxy來(lái)實(shí)現(xiàn) 偽多繼承，填補(bǔ)了多繼承的空白

• NSProxy 和 NSObject是同級(jí)的一個(gè)類(lèi)，也可以說(shuō)是一個(gè)虛擬類(lèi)，只是實(shí)現(xiàn)了NSObject的協(xié)議

• NSProxy 其實(shí)是一個(gè)消息重定向封裝的一個(gè)抽象類(lèi)，類(lèi)似一個(gè)代理人，中間件，可以通過(guò)繼承它，并重寫(xiě)下面兩個(gè)方法來(lái)實(shí)現(xiàn)消息轉(zhuǎn)發(fā)到另一個(gè)實(shí)例

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

使用場(chǎng)景

NSProxy的使用場(chǎng)景主要有兩種

• 實(shí)現(xiàn)多繼承功能
• 解決了NSTimer&CADisplayLink創(chuàng)建時(shí)對(duì)self強(qiáng)引用問(wèn)題，參考YYKit的YYWeakProxy。

循環(huán)引用解決原理

主要是通過(guò)自定義的NSProxy類(lèi)的對(duì)象來(lái)代替self，并使用方法實(shí)現(xiàn)消息轉(zhuǎn)發(fā)

下面是NSProxy子類(lèi)的實(shí)現(xiàn)以及使用的場(chǎng)景

• 自定義一個(gè)NSProxy的子類(lèi)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.有了方法簽名之后就會(huì)調(diào)用方法實(shí)現(xiàn)
- (void)forwardInvocation:(NSInvocation *)invocation{
    SEL sel = [invocation selector];
    if ([self.objc respondsToSelector:sel]) {
        [invocation invokeWithTarget:self.objc];
    }
}

//1、查詢?cè)摲椒ǖ姆椒ê灻?- (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類(lèi)和Dog類(lèi)

//********Cat類(lèi)********
@interface Cat : NSObject
@end

@implementation Cat
- (void)eat{
   NSLog(@"貓吃魚(yú)");
}
@end

//********Dog類(lèi)********
@interface Dog : NSObject
@end

@implementation Dog
- (void)shut{
    NSLog(@"狗叫");
}
@end

• 通過(guò)CJLProxy實(shí)現(xiàn)多繼承功能

- (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)];
}

• 通過(guò)CJLProxy解決定時(shí)器中self的強(qiáng)引用問(wèn)題

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

總結(jié)

循環(huán)應(yīng)用的解決方式從根本上來(lái)說(shuō)就兩種，以self -> block -> self為例

• 打破self 對(duì) block的強(qiáng)引用，可以block屬性修飾符使用weak，但是這樣會(huì)導(dǎo)致block還每創(chuàng)建完就釋放了，所以從這里打破強(qiáng)引用行不通

• 打破block對(duì)self的強(qiáng)引用，主要就是self的作用域和block作用域的通訊，通訊有代理、傳值、通知、傳參等幾種方式，用于解決循環(huán)，常見(jiàn)的解決方式如下：

  • weak-strong-dance

  • __block(block內(nèi)對(duì)象置空，且調(diào)用block)

  • 將對(duì)象self作為block的參數(shù)

  • 通過(guò)NSProxy的子類(lèi)代替self

Block 底層分析

主要是通過(guò)clang、斷點(diǎn)調(diào)試等方式分析Block底層

本質(zhì)

• 定義block.c文件

#include "stdio.h"

int main(){

    void(^block)(void) = ^{
        printf("CJL");
    };
    return 0;
}

• 通過(guò)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");
}

//******簡(jiǎn)化******
void(*block)(void) = __main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA));//構(gòu)造函數(shù)

block->FuncPtr(block);//block調(diào)用執(zhí)行

相當(dāng)于block等于__main_block_impl_0，是一個(gè)函數(shù)

• 查看__main_block_impl_0，是一個(gè)結(jié)構(gòu)體，同時(shí)可以說(shuō)明block是一個(gè)__main_block_impl_0類(lèi)型的對(duì)象，這也是為什么block能夠%@打印的原因

//**block代碼塊的結(jié)構(gòu)體類(lèi)型**
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的結(jié)構(gòu)體類(lèi)型**
struct __block_impl {
  void *isa;
  int Flags;
  int Reserved;
  void *FuncPtr;
};

總結(jié)：block的本質(zhì)是對(duì)象、函數(shù)、結(jié)構(gòu)體，由于block函數(shù)沒(méi)有名稱，也被稱為匿名函數(shù)

block通過(guò)clang編譯后的源碼間的關(guān)系如下所示，以__block修飾的變量為例

關(guān)系圖示

1、block為什么需要調(diào)用

在底層block的類(lèi)型__main_block_impl_0結(jié)構(gòu)體，通過(guò)其同名構(gòu)造函數(shù)創(chuàng)建，第一個(gè)傳入的block的內(nèi)部實(shí)現(xiàn)代碼塊，即__main_block_func_0，用fp表示，然后賦值給impl的FuncPtr屬性，然后在main中進(jìn)行了調(diào)用，這也是block為什么需要調(diào)用的原因。如果不調(diào)用，block內(nèi)部實(shí)現(xiàn)的代碼塊將無(wú)法執(zhí)行，可以總結(jié)為以下兩點(diǎn)

• 函數(shù)聲明：即block內(nèi)部實(shí)現(xiàn)聲明成了一個(gè)函數(shù)__main_block_func_0

• 執(zhí)行具體的函數(shù)實(shí)現(xiàn)：通過(guò)調(diào)用block的FuncPtr指針，調(diào)用block執(zhí)行

2、block是如何獲取外界變量的

• 定義一個(gè)變量，并在block中調(diào)用

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;//編譯時(shí)就自動(dòng)生成了相應(yīng)的變量
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _a, int flags=0) : a(_a) {
    impl.isa = &_NSConcreteStackBlock;//block的isa默認(rèn)是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，此時(shí)的a與傳入的__cself的a并不是同一個(gè)

        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是值拷貝，如果此時(shí)在block內(nèi)部實(shí)現(xiàn)中作 a++操作，是有問(wèn)題的，會(huì)造成編譯器的代碼歧義，即此時(shí)的a是只讀的

總結(jié)：block捕獲外界變量時(shí)，在內(nèi)部會(huì)自動(dòng)生成同一個(gè)屬性來(lái)保存

__block的原理

• 對(duì)a加一個(gè)__block，然后在block中對(duì)a進(jìn)行++操作

int main(){

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

• 底層編譯為如下

  • main中的a是通過(guò)外界變量封裝的對(duì)象

  • __main_block_impl_0中，將對(duì)象a的地址&a給構(gòu)造函數(shù)

  • 在__main_block_func_0內(nèi)部對(duì)a的處理是指針拷貝，此時(shí)創(chuàng)建的對(duì)象a與傳入對(duì)象的a指向同一片內(nèi)存空間

struct __Block_byref_a_0 {//__block修飾的外界變量的結(jié)構(gòu)體
  void *__isa;
__Block_byref_a_0 *__forwarding;
 int __flags;
 int __size;
 int a;
};

struct __main_block_impl_0 {//block的結(jié)構(gòu)體類(lèi)型
  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) {//構(gòu)造方法
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {//block內(nèi)部實(shí)現(xiàn)
  __Block_byref_a_0 *a = __cself->a; // bound by ref 指針拷貝，此時(shí)的對(duì)象a 與 __cself對(duì)象的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 是結(jié)構(gòu)體，a 等于 結(jié)構(gòu)體的賦值，即將外界變量a 封裝成對(duì)象
    //&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中的第三個(gè)參數(shù)&a，是封裝的對(duì)象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;
}

總結(jié)：

• 外界變量會(huì)生成__Block_byref_a_0結(jié)構(gòu)體

• 結(jié)構(gòu)體用來(lái)保存原始變量的指針和值

• 將變量生成的結(jié)構(gòu)體對(duì)象的指針地址 傳遞給block，然后在block內(nèi)部就可以對(duì)外界變量進(jìn)行操作了

兩種拷貝對(duì)比如下

• 值拷貝 - 深拷貝，只是拷貝數(shù)值，且拷貝的值不可更改，指向不同的內(nèi)存空間，案例中普通變量a就是值拷貝

• 指針拷貝 - 淺拷貝，生成的對(duì)象指向同一片內(nèi)存空間，案例中經(jīng)過(guò)__block修飾的變量a就是指針拷貝

block底層真正類(lèi)型

分析block源碼所在位置

• 通過(guò)在block處打斷點(diǎn)，分析運(yùn)行時(shí)的block

  
  
  image

• 加objc_retainBlock 符號(hào)斷點(diǎn)，發(fā)現(xiàn)會(huì)走到_Block_copy
  

  image

• 加_Block_copy符號(hào)斷點(diǎn)，運(yùn)行斷住，在libsystem_blocks.dylib源碼中
  

  image

可以到蘋(píng)果開(kāi)源網(wǎng)站下載最新的libclosure-74源碼,通過(guò)查看_Block_copy的源碼實(shí)現(xiàn)，發(fā)現(xiàn)block在底層的真正類(lèi)型是Block_layout

Block真正類(lèi)型

查看Block_layout類(lèi)型的定義，是一個(gè)結(jié)構(gòu)體

// CJL注釋:Block 結(jié)構(gòu)體
struct Block_layout {
    //指向表明block類(lèi)型的類(lèi)
    void *isa;//8字節(jié)
    //用來(lái)作標(biāo)識(shí)符的，類(lèi)似于isa中的位域,按bit位表示一些block的附加信息
    volatile int32_t flags; // contains ref count 4字節(jié)
    //保留信息，可以理解預(yù)留位置，用于存儲(chǔ)block內(nèi)部變量信息
    int32_t reserved;//4字節(jié)
    //函數(shù)指針，指向具體的block實(shí)現(xiàn)的調(diào)用地址
    BlockInvokeFunction invoke;
    //block的附加信息
    struct Block_descriptor_1 *descriptor;
    // imported variables
};

• isa：指向表明block類(lèi)型的類(lèi)
• flags：標(biāo)識(shí)符，按bit位表示一些block的附加信息，類(lèi)似于isa中的位域，其中flags的種類(lèi)有以下幾種，主要重點(diǎn)關(guān)注BLOCK_HAS_COPY_DISPOSE 和 BLOCK_HAS_SIGNATURE。 BLOCK_HAS_COPY_DISPOSE 決定是否有 Block_descriptor_2。BLOCK_HAS_SIGNATURE 決定是否有 Block_descriptor_3

  • 第1 位 - BLOCK_DEALLOCATING，釋放標(biāo)記，-般常用 BLOCK_NEEDS_FREE 做 位與 操作，一同傳入 Flags ， 告知該 block 可釋放。

  • 低16位 - BLOCK_REFCOUNT_MASK，存儲(chǔ)引用計(jì)數(shù)的值;是一個(gè)可選用參數(shù)

  • 第24位 - BLOCK_NEEDS_FREE，低16是否有效的標(biāo)志，程序根據(jù)它來(lái)決定是否增加或是減少引用計(jì)數(shù)位的 值;

  • 第25位 - BLOCK_HAS_COPY_DISPOSE，是否擁有拷貝輔助函數(shù)(a copy helper function);

  • 第26位 - BLOCK_IS_GC，是否擁有 block 析構(gòu)函數(shù);

  • 第27位，標(biāo)志是否有垃圾回收;//OS X

  • 第28位 - BLOCK_IS_GLOBAL，標(biāo)志是否是全局block;

  • 第30位 - BLOCK_HAS_SIGNATURE，與 BLOCK_USE_STRET 相對(duì)，判斷當(dāng)前 block 是否擁有一個(gè)簽名。用于 runtime 時(shí)動(dòng)態(tài)調(diào)用。

// CJL注釋: flags 標(biāo)識(shí)
// Values for Block_layout->flags to describe block objects
enum {
    //釋放標(biāo)記，一般常用于BLOCK_BYREF_NEEDS_FREE做位與運(yùn)算，一同傳入flags，告知該block可釋放
    BLOCK_DEALLOCATING =      (0x0001),  // runtime
    //存儲(chǔ)引用引用計(jì)數(shù)的 值，是一個(gè)可選用參數(shù)
    BLOCK_REFCOUNT_MASK =     (0xfffe),  // runtime
    //低16位是否有效的標(biāo)志，程序根據(jù)它來(lái)決定是否增加或者減少引用計(jì)數(shù)位的值
    BLOCK_NEEDS_FREE =        (1 << 24), // runtime
    //是否擁有拷貝輔助函數(shù)，（a copy helper function）決定block_description_2
    BLOCK_HAS_COPY_DISPOSE =  (1 << 25), // compiler
    //是否擁有block C++析構(gòu)函數(shù)
    BLOCK_HAS_CTOR =          (1 << 26), // compiler: helpers have C++ code
    //標(biāo)志是否有垃圾回收，OSX
    BLOCK_IS_GC =             (1 << 27), // runtime
    //標(biāo)志是否是全局block
    BLOCK_IS_GLOBAL =         (1 << 28), // compiler
    //與BLOCK_HAS_SIGNATURE相對(duì)，判斷是否當(dāng)前block擁有一個(gè)簽名，用于runtime時(shí)動(dòng)態(tài)調(diào)用
    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：保留信息，可以理解預(yù)留位置，猜測(cè)是用于存儲(chǔ)block內(nèi)部變量信息

• invoke：是一個(gè)函數(shù)指針，指向block的執(zhí)行代碼

• descriptor：block的附加信息，比如保留變量數(shù)、block的大小、進(jìn)行copy或dispose的輔助函數(shù)指針。有三類(lèi)

  • 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;//拷貝函數(shù)指針
    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 布局
};

以上關(guān)于descriptor的可以從其構(gòu)造函數(shù)中體現(xiàn)，其中Block_descriptor_2和Block_descriptor_3都是通過(guò)Block_descriptor_1的地址，經(jīng)過(guò)內(nèi)存平移得到的

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

// CJL注釋:Block 的描述 : copy 和 dispose 函數(shù)
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);//通過(guò)內(nèi)存平移獲取
    return (struct Block_descriptor_2 *)desc;
}

// CJL注釋: Block 的描述 : 簽名相關(guān)
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;
}

內(nèi)存變化

• 打斷點(diǎn)運(yùn)行，走到objc_retainBlock，block斷點(diǎn)處讀取寄存器x0，此時(shí)的block 是全局block ，即__NSGlobalBlock__類(lèi)型
  

  image

• 增加外部變量a，并在block內(nèi)打印

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

此時(shí)讀取block斷點(diǎn)處的x0 -- 棧block -- __NSStackBlock__

image

• 執(zhí)行到符號(hào)斷點(diǎn)objc_retainBlock時(shí)，還是棧區(qū)block
  

  image

• 增加_Block_copy符號(hào)斷點(diǎn)并斷住，直接在最后的ret加斷點(diǎn)，讀取x0，發(fā)現(xiàn)經(jīng)過(guò)_Block_copy之后，變成了 堆block，即__NSMallocBlock__，主要是因?yàn)?code>block地址發(fā)生了改變，為堆block
  

  image

調(diào)用情況

• 同樣也可以通過(guò)斷點(diǎn)來(lái)驗(yàn)證

  
  
  image

  • register read x0 讀取x0，為堆block

  • register read x9 讀取x9
    [站外圖片上傳中...(image-b14a19-1605377133592)]

  • register read x11 ，此時(shí)是指向一片內(nèi)存空間，用于存儲(chǔ)_block_invoke
    

    image

• 按住control + step into，進(jìn)入 _block_invoke，可以得出是通過(guò)內(nèi)存平移得到的block內(nèi)部實(shí)現(xiàn)
  

  image
  
  前面提到的Block_layout的結(jié)構(gòu)體源碼,從源碼中可以看出，有個(gè)屬性invoke，即block的執(zhí)行者，是從isa的首地址平移 16字節(jié)取到invoke，然后進(jìn)行調(diào)用執(zhí)行的

簽名

• 繼續(xù)操作，讀取x0寄存器,看內(nèi)存布局,通過(guò) 內(nèi)存平移 3*8 就可獲得Block_layout的屬性descriptor,主要是為了查看是否有Block_descriptor_2 和Block_descriptor_3，其中3中有block的簽名

  • register read x0，讀取寄存器x0
  • po 0x00000002828a2160 ， 打印block
  • x/8gx 0x00000002828a2160 ，即打印block內(nèi)存情況
    
    image
  • x/8gx 0x00000001008a0010 ， 查看descriptor的內(nèi)存情況，其中第三個(gè)0x000000010089f395表示簽名
    
    image

• 判斷是否有Block_descriptor_2，即flags的BLOCK_HAS_COPY_DISPOSE（拷貝輔助函數(shù)）是否有值

  • p/x 1<<25 ，即1左移25位，其十六進(jìn)制為0x2000000
  • p 0x02000000 & 0x00000000c1000002 ，即BLOCK_HAS_COPY_DISPOSE & flags ，等于0，表示沒(méi)有Block_descriptor_2
    
    image

• 判斷是否有Block_descriptor_3

  • p/x 1<<30，即1左移30位
  • p 0x40000000 & 0x00000000c1000002 ，即BLOCK_HAS_SIGNATURE & flags ，有值，說(shuō)明有Block_descriptor_3
    
    image
  • p (char *)0x000000010089f395 -- 獲取Block_descriptor_3中的屬性signature簽名
    
    image
  • po [NSMethodSignature signatureWithObjCTypes:"v8@?0"] ，即打印簽名
    
    image

其中簽名的部分說(shuō)明如下

//無(wú)返回值
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 = (@),類(lèi)型是 @?
    type encoding (@) '@?'
    //@是isObject ，？是isBlock，代表 isBlockObject
    flags {isObject, isBlock}
    modifiers {}
    frame {offset = 0, offset adjust = 0, size = 8, size adjust = 0}
    //所在偏移位置是8字節(jié)
    memory {offset = 0, size = 8}

block的簽名信息類(lèi)似于方法的簽名信息，主要是體現(xiàn)block的返回值，參數(shù)以及類(lèi)型等信息

block三次copy分析

_Block_copy源碼分析

• 進(jìn)入_Block_copy源碼，將block 從棧區(qū)拷貝至堆區(qū)

  • 如果需要釋放，如果需要?jiǎng)t直接釋放

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

  • 反之，只有兩種情況：棧區(qū)block or 堆區(qū)block，由于堆區(qū)block需要申請(qǐng)空間，前面并沒(méi)有申請(qǐng)空間的相關(guān)代碼，所以只能是棧區(qū)block，

    • 通過(guò)malloc申請(qǐng)內(nèi)存空間用于接收block

    • 通過(guò)memmove將block拷貝至新申請(qǐng)的內(nèi)存中

    • 設(shè)置block對(duì)象的類(lèi)型為堆區(qū)block，即result->isa = _NSConcreteMallocBlock

// Copy, or bump refcount, of a block.  If really copying, call the copy helper if present.
// CJL重點(diǎn)提示: 這里是核心重點(diǎn) 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;//強(qiáng)轉(zhuǎn)為Block_layout類(lèi)型對(duì)象，防止對(duì)外界造成影響
    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，由于堆區(qū)需要申請(qǐng)內(nèi)存，所以只可能是棧區(qū)
        // Its a stack block.  Make a copy. 它是一個(gè)堆棧塊block，拷貝。
        struct Block_layout *result =
            (struct Block_layout *)malloc(aBlock->descriptor->size);//申請(qǐng)空間并接收
        if (!result) return NULL;
        //通過(guò)memmove內(nèi)存拷貝，將 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;//可以直接調(diào)起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;//設(shè)置block對(duì)象類(lèi)型為堆區(qū)block
        return result;
    }
}

_Block_object_assign 分析

想要分析block的三層copy，首先需要知道外部變量的種類(lèi)有哪些，其中用的最多的是BLOCK_FIELD_IS_OBJECT和BLOCK_FIELD_IS_BYREF

// CJL注釋: Block 捕獲的外界變量的種類(lèi)
// 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
    //普通對(duì)象，即沒(méi)有其他的引用類(lèi)型
    BLOCK_FIELD_IS_OBJECT   =  3,  // id, NSObject, __attribute__((NSObject)), block, ...
    //block類(lèi)型作為變量
    BLOCK_FIELD_IS_BLOCK    =  7,  // a block variable
    //經(jīng)過(guò)__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
    //返回的調(diào)用對(duì)象 - 處理block_byref內(nèi)部對(duì)象內(nèi)存會(huì)加的一個(gè)額外標(biāo)記，配合flags一起使用
    BLOCK_BYREF_CALLER      = 128, // called from __block (byref) copy/dispose support routines.
};

而_Block_object_assign是在底層編譯代碼中，外部變量拷貝時(shí)調(diào)用的方法就是它

• 進(jìn)入_Block_object_assign源碼

  • 如果是普通對(duì)象，則交給系統(tǒng)arc處理，并拷貝對(duì)象指針，即引用計(jì)數(shù)+1，所以外界變量不能釋放

  • 如果是block類(lèi)型的變量，則通過(guò)_Block_copy操作，將block從棧區(qū)拷貝到堆區(qū)

  • 如果是__block修飾的變量，調(diào)用_Block_byref_copy函數(shù) 進(jìn)行內(nèi)存拷貝以及常規(guī)處理

static struct Block_byref *_Block_byref_copy(const void *arg) {
    
    //強(qiáng)轉(zhuǎn)為Block_byref結(jié)構(gòu)體類(lèi)型，保存一份
    struct Block_byref *src = (struct Block_byref *)arg;

    if ((src->forwarding->flags & BLOCK_REFCOUNT_MASK) == 0) {
        // src points to stack 申請(qǐng)內(nèi)存
        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內(nèi)部持有的Block_byref 和 外界的Block_byref 所持有的對(duì)象是同一個(gè)，這也是為什么__block修飾的變量具有修改能力
        //copy 和 scr 的地址指針達(dá)到了完美的同一份拷貝，目前只有持有能力
        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是結(jié)構(gòu)體，__block修飾的可能是對(duì)象，對(duì)象通過(guò)byref_keep保存，在合適的時(shí)機(jī)進(jìn)行調(diào)用
            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;
            }
            //等價(jià)于 __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;
}

• 進(jìn)入_Block_byref_copy源碼

  • 將傳入的對(duì)象，強(qiáng)轉(zhuǎn)為Block_byref結(jié)構(gòu)體類(lèi)型對(duì)象，保存一份

  • 沒(méi)有將外界變量拷貝到堆，需要申請(qǐng)內(nèi)存，其進(jìn)行拷貝

  • 如果已經(jīng)拷貝過(guò)了，則進(jìn)行處理并返回

  • 其中copy 和 src的forwarding指針都指向同一片內(nèi)存，這也是為什么__block修飾的對(duì)象具有修改能力的原因

static struct Block_byref *_Block_byref_copy(const void *arg) {
    
    //強(qiáng)轉(zhuǎn)為Block_byref結(jié)構(gòu)體類(lèi)型，保存一份
    struct Block_byref *src = (struct Block_byref *)arg;

    if ((src->forwarding->flags & BLOCK_REFCOUNT_MASK) == 0) {
        // src points to stack 申請(qǐng)內(nèi)存
        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內(nèi)部持有的Block_byref 和 外界的Block_byref 所持有的對(duì)象是同一個(gè)，這也是為什么__block修飾的變量具有修改能力
        //copy 和 scr 的地址指針達(dá)到了完美的同一份拷貝，目前只有持有能力
        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是結(jié)構(gòu)體，__block修飾的可能是對(duì)象，對(duì)象通過(guò)byref_keep保存，在合適的時(shí)機(jī)進(jìn)行調(diào)用
            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;
            }
            //等價(jià)于 __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;
}

代碼調(diào)試

• 定義一個(gè)__block修飾的NSString對(duì)象

 __block NSString *cjl_name = [NSString stringWithFormat:@"CJL"];
void (^block1)(void) = ^{ // block_copy
    lg_name = @"CJL";
    NSLog(@"CJL - %@",lg_name);
    
    // block 內(nèi)存
};
block1();

• xcrun編譯結(jié)果如下，

  • 編譯后的cjl_name比普通變量多了__Block_byref_id_object_copy_131 和 __Block_byref_id_object_dispose_131

  • __Block_byref_cjl_name_0結(jié)構(gòu)體中多了__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結(jié)構(gòu)體********
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結(jié)構(gòu)體拷貝(_Block_object_assign) -- _Block_object_assign中對(duì)外部變量（存儲(chǔ)在bref）拷貝一份到內(nèi)存
static void __Block_byref_id_object_copy_131(void *dst, void *src) {
    //dst 外部捕獲的變量，即結(jié)構(gòu)體 - 5*8 = 40，然后就找到了cjl_name(cjl_name在bref初始化時(shí)就賦值了)
    _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);
}

• 通過(guò)libclosure-74可編譯源碼斷點(diǎn)調(diào)試，關(guān)鍵方法的執(zhí)行順序?yàn)椋?code>_Block_copy -> _Block_byref_copy -> _Block_object_assign,正好對(duì)應(yīng)上述的三層copy

綜上所述，block是如何取到 cjl_name的？

• 1、通過(guò)_Block_copy方法，將block拷貝一份至堆區(qū)

• 2、通過(guò)_Block_object_assign方法正常拷貝，因?yàn)?code>__block修飾的外界變量在底層是 Block_byref結(jié)構(gòu)體

• 3、發(fā)現(xiàn)外部變量還存有一個(gè)對(duì)象，從bref中取出相應(yīng)對(duì)象cjl_name，拷貝至block空間，才能使用（相同空間才能使用，不同則不能使用）。最后通過(guò)內(nèi)存平移就得到了cjl_name，此時(shí)的cjl_name 和 外界的cjl_name是同一片內(nèi)存空間（從_Block_object_assign方法中的*dest = object;看出）

三層copy總結(jié)

所以，綜上所述，block的三層拷貝是指以下三層：

• 【第一層】通過(guò)_Block_copy實(shí)現(xiàn)對(duì)象的自身拷貝,從棧區(qū)拷貝至堆區(qū)

• 【第二層】通過(guò)_Block_byref_copy方法，將對(duì)象拷貝為Block_byref結(jié)構(gòu)體類(lèi)型

• 【第三層】調(diào)用_Block_object_assign方法，對(duì)__block修飾的當(dāng)前變量的拷貝

注：只有__block修飾的對(duì)象，block的copy才有三層

_Block_object_dispose 分析

同一般的retain和release一樣，_Block_object_object其本質(zhì)主要是retain，所以對(duì)應(yīng)的還有一個(gè)release，即_Block_object_dispose方法，其源碼實(shí)現(xiàn)如下，也是通過(guò)區(qū)分block種類(lèi)，進(jìn)行不同釋放操作

// When Blocks or Block_byrefs hold objects their destroy helper routines call this entry point
// to help dispose of the contents 當(dāng)Blocks或Block_byrefs持有對(duì)象時(shí)，其銷(xiāo)毀助手例程將調(diào)用此入口點(diǎn)以幫助處置內(nèi)容
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類(lèi)型的
        // get rid of the __block data structure held in a Block
        _Block_byref_release(object);
        break;
      case BLOCK_FIELD_IS_BLOCK://block類(lèi)型的變量
        _Block_release(object) ;
        break;
      case BLOCK_FIELD_IS_OBJECT://普通對(duì)象
        _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;
    }
}

• 進(jìn)入_Block_byref_release源碼，主要就是對(duì)象、變量的釋放銷(xiāo)毀

static void _Block_byref_release(const void *arg) {
    //對(duì)象強(qiáng)轉(zhuǎn)為Block_byref類(lèi)型結(jié)構(gòu)體
    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) {//是否有拷貝輔助函數(shù)
                struct Block_byref_2 *byref2 = (struct Block_byref_2 *)(byref+1);
                (*byref2->byref_destroy)(byref);//銷(xiāo)毀拷貝對(duì)象
            }
            free(byref);//釋放
        }
    }
}

所以，綜上所述，Block的三層copy的流程如下圖所示

三層copy流程