一、Block循环引用
正常释放：是指A持有B的引用，当A 调用 delloc 方法，给B发送release信号，B收到release 信号，如果此时 Bd额retainCount 为0时，则调用B的dealloc方法
循环引用：A、B 相互持有
//代码一
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 主要有三种类型：
NSGlobalBlock 、 NSMallocBlock 、 NSStackBlock
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 函数没有名称，也称为 匿名函数
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 类型
- 增加外部变量a，并在block 内打印
int a = 10;
void (^block1)(void) = ^{
NSLog(@"XXX - %d", a);
};
block1();
此时读取block 断点处的 xo -- 栈block -- NSStackBlock
- 执行到符号断点 objc_retainBlock 时，还是在栈区block
- 增加 _block_copy 符合断点并断往，直接在最后的ret加断点，读取xo，发现经过_block_copy之后，变成了 堆block ，即NSMallocBlock,主要是因为block 地址发生了改变，为堆block
调用情况
- 同样也可以通过断点来验证
1、 register read xo 读取xo，为堆block
2、 register read x9 读取 x9
3、register read x11 ，此时是指向一片内存空间，用于存储 _block_invoke
4、按住 control + step into，进入 _block_invoke,可以得出是通过 内存平移得到的block 内部实现
前面提到的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 内存情况
- x/8gx 0x00000001008a0010，查看descriptor 的内存情况，其中第三个0x000000010089f395 表示签名
- 判断是否有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
- 判断是否有Block_descriptor_3
p/x 1<< 30 ,即1 左移 30 位
p 0x40000000 & 0x00000000c1000002 ，即 BLOCK_HAS_SIGNATURE & flags，有值，说明有 Block_descriptor_3
p (char *) 0x000000010089f395 获取block_descriptor_3 中的属性signature 签名
po [NSMethodSignature signatureWithObjCTypes:"v8@?0"] 即 打印签名
四、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);//释放
}
}
}