block類型
block主要有三種類型
-
__NSGlobalBlock__：全局block，存儲在全局區(qū)
void(^block)(void) = ^{
NSLog(@"HX");
};
NSLog(@"%@", block);
此時的block沒有訪問外部變量，屬于全局block
-
__NSMallocBlock__：堆區(qū)block，因為block既是函數(shù)，也是對象
int a = 10;
void(^block)(void) = ^{
NSLog(@"HX - %d", a);
};
NSLog(@"%@", block);
此時的block會訪問外界變量，即底層拷貝a，屬于堆區(qū)block
-
__NSStackBlock__：棧區(qū)block
int a = 10;
void(^block)(void) = ^{
NSLog(@"HX - %d", a);
};
NSLog(@"%@", ^{
NSLog(@"HX - %d", a);
});
由于xcode做了優(yōu)化，之前打印的是棧區(qū)block，現(xiàn)在打印的是堆區(qū)block，如下：
我們換個思路，通過__weak打印出來的就是棧區(qū)block，如下：
int a = 10;
void (^__weak block)(void) = ^{
NSLog(@"Cooci - %d",a);
};
NSLog(@"%@",block);
block循環(huán)引用
什么是循環(huán)引用
代碼如下：
這就是最典型的block循環(huán)引用
解決方案:
1.我們大家熟知的，weak-strong-dance
- (void)viewDidLoad {
[super viewDidLoad];
__weak typeof(self) weakSelf = self;
self.name = @"hx";
self.block = ^(void){
__strong typeof(self) strongSelf = weakSelf;
NSLog(@"%@", strongSelf.name);
};
self.block();
}
為什么__weak要轉(zhuǎn)換成__strong，因為block塊內(nèi)要是進行一些耗時操作的話，會導(dǎo)致block過早釋放，那么就會造成一些異常，所以要用__strong
2.self-block-vc,通過中介者模式打破循環(huán)引用
手動模式
- (void)viewDidLoad {
[super viewDidLoad];
self.name = @"hx";
__block ViewController *vc = self;
self.block = ^(void){
NSLog(@"%@", vc.name);
vc = nil;
};
self.block();
}
注意，__block外部變量使用完成后，記得置為nil，否則引發(fā)內(nèi)存泄露
3.block中添加參數(shù)
自動模式
typedef void(^KCBlock)(ViewController *);
- (void)viewDidLoad {
[super viewDidLoad];
self.name = @"lg_cooci";
self.block = ^(ViewController *vc){
NSLog(@"%@", vc.name);
};
self.block(self);
}
這種和上面一種方式差不多，這種不需要手動置為nil
block底層分析
主要是通過clang、斷點調(diào)試等方式分析block底層
本質(zhì)
- 定義
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));//構(gòu)造函數(shù)
block->FuncPtr(block);//block調(diào)用執(zhí)行
相當(dāng)于block等于__main_block_impl_0，是一個函數(shù)
- 查看__main_block_impl_0，是一個結(jié)構(gòu)體，同時可以說明block是一個__main_block_impl_0類型的對象，這也是為什么block能夠%@打印的原因
//**block代碼塊的結(jié)構(gòu)體類型**
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)體類型**
struct __block_impl {
void *isa;
int Flags;
int Reserved;
void *FuncPtr;
};
總結(jié)：block的本質(zhì)是對象、函數(shù)、結(jié)構(gòu)體，由于block函數(shù)沒有名稱，也被稱為匿名函數(shù)
block通過clang編譯后的源碼間的關(guān)系如下所示，以__block修飾的變量為例
1、block為什么需要調(diào)用
在底層block的類型__main_block_impl_0結(jié)構(gòu)體，通過其同名構(gòu)造函數(shù)創(chuàng)建，第一個傳入的block的內(nèi)部實現(xiàn)代碼塊，即__main_block_func_0，用fp表示，然后賦值給impl的FuncPtr屬性，然后在main中進行了調(diào)用，這也是block為什么需要調(diào)用的原因。如果不調(diào)用，block內(nèi)部實現(xiàn)的代碼塊將無法執(zhí)行，可以總結(jié)為以下兩點
函數(shù)聲明：即block內(nèi)部實現(xiàn)聲明成了一個函數(shù)__main_block_func_0
執(zhí)行具體的函數(shù)實現(xiàn)：通過調(diào)用block的FuncPtr指針，調(diào)用block執(zhí)行
2、block是如何獲取外界變量的
- 定義一個變量，并在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;//編譯時就自動生成了相應(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默認是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內(nèi)部實現(xiàn)中作 a++操作，是有問題的，會造成編譯器的代碼歧義，即此時的a是只讀的
總結(jié)：block捕獲外界變量時，在內(nèi)部會自動生成同一個屬性來保存
__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給構(gòu)造函數(shù)
在__main_block_func_0內(nèi)部對a的處理是指針拷貝，此時創(chuàng)建的對象a與傳入對象的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)體類型
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)部實現(xiàn)
__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 是結(jié)構(gòu)體，a 等于 結(jié)構(gòu)體的賦值，即將外界變量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中的第三個參數(shù)&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;
}
總結(jié)：
外界變量會生成__Block_byref_a_0結(jié)構(gòu)體
結(jié)構(gòu)體用來保存原始變量的指針和值
將變量生成的結(jié)構(gòu)體對象的指針地址 傳遞給block，然后在block內(nèi)部就可以對外界變量進行操作了
兩種拷貝對比如下
值拷貝 - 淺拷貝，只是拷貝數(shù)值，且拷貝的值不可更改，指向不同的內(nèi)存空間，案例中普通變量a就是值拷貝
指針拷貝 - 深拷貝，生成的對象指向同一片內(nèi)存空間，案例中經(jīng)過__block修飾的變量a就是指針拷貝
block底層真正類型
分析block源碼所在位置
-
通過在block處打斷點，分析運行時的block
image
-
加objc_retainBlock符號斷點，發(fā)現(xiàn)會走到_Block_copy
image 加_Block_copy符號斷點，運行斷住，在libsystem_blocks.dylib源碼中
可以到蘋果開源網(wǎng)站下載最新的libclosure-74源碼,通過查看_Block_copy的源碼實現(xiàn)，發(fā)現(xiàn)block在底層的真正類型是Block_layout
block真正類型
查看Block_layout類型的定義，是一個結(jié)構(gòu)體
// CJL注釋:Block 結(jié)構(gòu)體
struct Block_layout {
//指向表明block類型的類
void *isa;//8字節(jié)
//用來作標(biāo)識符的，類似于isa中的位域,按bit位表示一些block的附加信息
volatile int32_t flags; // contains ref count 4字節(jié)
//保留信息，可以理解預(yù)留位置，用于存儲block內(nèi)部變量信息
int32_t reserved;//4字節(jié)
//函數(shù)指針，指向具體的block實現(xiàn)的調(diào)用地址
BlockInvokeFunction invoke;
//block的附加信息
struct Block_descriptor_1 *descriptor;
// imported variables
};
isa：指向表明block類型的類
flags：標(biāo)識符，按bit位表示一些block的附加信息，類似于isa中的位域，其中flags的種類有以下幾種，主要重點關(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，存儲引用計數(shù)的值;是一個可選用參數(shù)
第24位 - BLOCK_NEEDS_FREE，低16是否有效的標(biāo)志，程序根據(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 相對，判斷當(dāng)前 block 是否擁有一個簽名。用于 runtime 時動態(tài)調(diào)用。
// CJL注釋: flags 標(biāo)識
// Values for Block_layout->flags to describe block objects
enum {
//釋放標(biāo)記，一般常用于BLOCK_BYREF_NEEDS_FREE做位與運算，一同傳入flags，告知該block可釋放
BLOCK_DEALLOCATING = (0x0001), // runtime
//存儲引用引用計數(shù)的 值，是一個可選用參數(shù)
BLOCK_REFCOUNT_MASK = (0xfffe), // runtime
//低16位是否有效的標(biāo)志，程序根據(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相對，判斷是否當(dāng)前block擁有一個簽名，用于runtime時動態(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ù)留位置，猜測是用于存儲block內(nèi)部變量信息
invoke：是一個函數(shù)指針，指向block的執(zhí)行代碼
descriptor：block的附加信息，比如保留變量數(shù)、block的大小、進行copy或dispose的輔助函數(shù)指針。有三類
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都是通過Block_descriptor_1的地址，經(jīng)過內(nèi)存平移得到的
static struct Block_descriptor_1 * _Block_descriptor_1(struct Block_layout *aBlock)
{
return aBlock->descriptor;//默認打印
}
#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);//通過內(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)存變化
打斷點運行，block斷點處讀取寄存器raw，我這邊用的是模擬器，所以讀的是raw，要是用真機的話，讀下x0就行了，此時的block 是全局block ，即NSGlobalBlock類型
- 增加外部變量a，并在block內(nèi)打印
此時讀取block斷點處的x0 -- 棧block -- NSStackBlock
-
執(zhí)行到符號斷點objc_retainBlock時，還是棧區(qū)block
image -
在block調(diào)用的地方加個斷點，我們發(fā)現(xiàn)執(zhí)行了objc_retainBlock之后，我們再讀取寄存器x0,變成了 堆block，即NSMallocBlock，主要是因為block地址發(fā)生了改變，為堆block
image
image
簽名
繼續(xù)操作，讀取x0寄存器,看內(nèi)存布局,通過 內(nèi)存平移 3*8 就可獲得Block_layout的屬性descriptor,主要是為了查看是否有Block_descriptor_2 和Block_descriptor_3，其中3中有block的簽名
register read x0，讀取寄存器x0
po 0x000000028124def0 ， 打印block
x/8gx 0x000000028124def0 ，即打印block內(nèi)存情況
-
x/8gx 0x0000000104ef0010 ， 查看descriptor的內(nèi)存情況，其中第三個x0000000104eef390表示簽名
image
判斷是否有Block_descriptor_2，即flags的BLOCK_HAS_COPY_DISPOSE（拷貝輔助函數(shù)）是否有值
p/x 1<<25 ，即1左移25位，其十六進制為0x2000000
p 0x02000000 & 0x00000000c1000002 ，即BLOCK_HAS_COPY_DISPOSE & flags ，等于0，表示沒有Block_descriptor_2
判斷是否有Block_descriptor_3
p/x 1<<30，即1左移30位
-
p 0x40000000 & 0x00000000c1000002 ，即BLOCK_HAS_SIGNATURE & flags ，有值，說明有Block_descriptor_3
image p (char *)0x0000000104eef390 -- 獲取Block_descriptor_3中的屬性signature簽名
-
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字節(jié)
memory {offset = 0, size = 8}
block的簽名信息類似于方法的簽名信息，主要是體現(xiàn)block的返回值，參數(shù)以及類型等信息
block三次copy分析
進入_Block_copy源碼，將block 從棧區(qū)拷貝至堆區(qū)
如果需要釋放，如果需要則直接釋放
如果是globalBlock -- 不需要copy，直接返回
反之，只有兩種情況：棧區(qū)block or 堆區(qū)block，由于堆區(qū)block需要申請空間，前面并沒有申請空間的相關(guān)代碼，所以只能是棧區(qū)block，
通過malloc申請內(nèi)存空間用于接收block
通過memmove將block拷貝至新申請的內(nèi)存中
設(shè)置block對象的類型為堆區(qū)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;//強轉(zhuǎn)為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，由于堆區(qū)需要申請內(nèi)存，所以只可能是棧區(qū)
// Its a stack block. Make a copy. 它是一個堆棧塊block，拷貝。
struct Block_layout *result =
(struct Block_layout *)malloc(aBlock->descriptor->size);//申請空間并接收
if (!result) return NULL;
//通過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對象類型為堆區(qū)block
return result;
}
}
_Block_object_assign 分析
想要分析block的三層copy，首先需要知道外部變量的種類有哪些，其中用的最多的是BLOCK_FIELD_IS_OBJECT和BLOCK_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
//經(jīng)過__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)用對象 - 處理block_byref內(nèi)部對象內(nèi)存會加的一個額外標(biāo)記，配合flags一起使用
BLOCK_BYREF_CALLER = 128, // called from __block (byref) copy/dispose support routines.
};
而_Block_object_assign是在底層編譯代碼中，外部變量拷貝時調(diào)用的方法就是它
進入_Block_object_assign源碼
如果是普通對象，則交給系統(tǒng)arc處理，并拷貝對象指針，即引用計數(shù)+1，所以外界變量不能釋放
如果是block類型的變量，則通過_Block_copy操作，將block從棧區(qū)拷貝到堆區(qū)
如果是__block修飾的變量，調(diào)用_Block_byref_copy函數(shù) 進行內(nèi)存拷貝以及常規(guī)處理
static struct Block_byref *_Block_byref_copy(const void *arg) {
//強轉(zhuǎn)為Block_byref結(jié)構(gòu)體類型，保存一份
struct Block_byref *src = (struct Block_byref *)arg;
if ((src->forwarding->flags & BLOCK_REFCOUNT_MASK) == 0) {
// src points to stack 申請內(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 所持有的對象是同一個，這也是為什么__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是結(jié)構(gòu)體，__block修飾的可能是對象，對象通過byref_keep保存，在合適的時機進行調(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;
}
//等價于 __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源碼
將傳入的對象，強轉(zhuǎn)為Block_byref結(jié)構(gòu)體類型對象，保存一份
沒有將外界變量拷貝到堆，需要申請內(nèi)存，其進行拷貝
如果已經(jīng)拷貝過了，則進行處理并返回
其中copy 和 src的forwarding指針都指向同一片內(nèi)存，這也是為什么__block修飾的對象具有修改能力的原因
static struct Block_byref *_Block_byref_copy(const void *arg) {
//強轉(zhuǎn)為Block_byref結(jié)構(gòu)體類型，保存一份
struct Block_byref *src = (struct Block_byref *)arg;
if ((src->forwarding->flags & BLOCK_REFCOUNT_MASK) == 0) {
// src points to stack 申請內(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 所持有的對象是同一個，這也是為什么__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是結(jié)構(gòu)體，__block修飾的可能是對象，對象通過byref_keep保存，在合適的時機進行調(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;
}
//等價于 __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;
}
三層copy總結(jié)
所以，綜上所述，block的三層拷貝是指以下三層：
【第一層】通過_Block_copy實現(xiàn)對象的自身拷貝,從棧區(qū)拷貝至堆區(qū)
【第二層】通過_Block_byref_copy方法，將對象拷貝為Block_byref結(jié)構(gòu)體類型
【第三層】調(diào)用_Block_object_assign方法，對__block修飾的當(dāng)前變量的拷貝
注：只有__block修飾的對象，block的copy才有三層
_Block_object_dispose 分析
同一般的retain和release一樣，_Block_object_object其本質(zhì)主要是retain，所以對應(yīng)的還有一個release，即_Block_object_dispose方法，其源碼實現(xiàn)如下，也是通過區(qū)分block種類，進行不同釋放操作
// 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持有對象時，其銷毀助手例程將調(diào)用此入口點以幫助處置內(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類型的
// 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) {
//對象強轉(zhuǎn)為Block_byref類型結(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);//銷毀拷貝對象
}
free(byref);//釋放
}
}
}
