3. __block  __weak  __strong   这都是做什么的

1.1 局部变量

局部自动变量,在Block中可被读取。Block定义时copy变量的值,在Block中作为常量使用,所以即使变量的值在Block外改变,也不影响他在Block中的值,Block此时对局部变量只是做了值传递的操作。

1.2 static 修饰的全局变量

因为全局变量或静态变量在内存中的地址是固定的,Block在读取该变量值的时候是直接从其所在内存地址读出,获取到的是最新值,而不是在定义时copy的常量。

1.3 对OC对象的截获

NSMutableArray *array = [NSMutableArray array];

void(^block)() = ^(){

NSObject *obj = [[NSObject alloc] init];

[array addObject:obj];

};

block();

上述代码编译通过,Block截获的值为NSMutableArray类的对象,用C语言表述,就是用的NSMutableArray类的对象所用的结构体实例的指针,所以向该对象中添加元素操作属于使用截获变量的值,因此是没有问题的。那么对该截获的变量进行赋值

屏幕快照 2016-06-23 下午2.12.28.png

编译未通过,提示缺少__block修饰符。

1.4 C语言数组

屏幕快照 2016-06-23 下午2.18.28.png

上图代码中, 在Block外部定义一个C语言字符串字面量数组, 在Block内部截获自动变量的方法并没有实现对C语言数组的截获, 此时访问数组元素text[2]会报错. 此时使用指针可以解决.

const char *text = "adsdczv";

void(^block)() = ^(){

NSLog(@"%c",text[2]);

};

block();

1.5__block 修饰的变量

某些场景下,我们需要在Block内部对外部变量进行修改。这时需要使用__block来修饰该变量实现在Block内部的修改,此时Block是复制其引用地址来实现访问的。

关于__block 修饰符

从上面讲解我们已经知道,Block内部能够读取外部局部变量的值。但如果我们需要在Block内部修改变量的值,则需要在Block外部给该变量添加一个__block修饰符。

__block另一个使用场景是,避免某些情况下Block使用中出现的循环引用的问题,此时可以给相应的对象加上一个__block来修饰。

为什么使用__block可以实现在Block内部修改外部变量的值?

这边我们用一个Block代码,并使用clang _rewrite_objc命令转换成C++的代码来说明__block是怎么实现内部变量的修改。

Block在main中实现

int main(int argc, const char * argv[]) {

@autoreleasepool {

NSInteger val = 10;

void (^block)(void) = ^{

NSLog(@"%ld", val);

};

block();

}

return 0;

}

转码后:

struct __main_block_impl_0 {

struct __block_impl impl;

struct __main_block_desc_0* Desc;

int val;

__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _val, int flags=0) : val(_val) {

impl.isa = &_NSConcreteStackBlock;

impl.Flags = flags;

impl.FuncPtr = fp;

Desc = desc;

}

};

static void __main_block_func_0(struct  __main_block_impl_0 *__cself) {

int val = __cself->val;  // bound by copy

NSLog((NSString *)&__NSConstantStringImpl__val_folders_gm_0jk35cwn1d3326x0061qym280000gn_T_main_41daf1_mi_0, val);

}

static struct __main_block_desc_0 {

size_t reserved;

size_t Block_size;

} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};

int main(int argc, const char * argv[]) {

/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;

int val = 10;

void (*block)(void) = (void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, val);

((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);

}

return 0;

}

从展开代码可以发现,Block被转成了一个struct __main_block_impl_0类型的结构体实例,并且该结构体成员中包含局部变量val。当执行Block时,通过该实例找到Block执行部分void __main_block_func_0,并把该结构体实例传入到void __main_block_func_0方法中。

void __main_block_func_0方法中第一个参数声明如下

struct __main_block_impl_0 *__cself

注意:这里的__cself就类似于OC中的self,而它指向结构体的指针。

此时我们就可以通过__cself->val访问该局部变量。

那么问题来了,为什么此时不对变量val进行修改?

因为main函数中的局部变量val和函数__main_block_func_0不在同一个作用域中,调用过程中只是进行了值传递。

当然,在上面代码中,我们可以通过指针来实现局部变量的修改。不过这是由于在调用__main_block_func_0时,main函数栈还没展开完成,变量val还在栈中。

但是在很多情况下,Block是作为参数传递以供后续回调执行的。通常在这些情况下,Block被执行时,定义时所在的函数栈已经被展开,局部变量已经不在栈中了,再用指针访问会产生野指针错误。

所以,这类情况下对于auto类型的局部变量,不允许Block进行修改是合理的。

__block是如何实现变量修改的

此时使用更新后的代码

添加__block修饰符后

int main(int argc, const char * argv[]) {

@autoreleasepool {

__block NSInteger val = 0;

void (^block)(void) = ^{

val = 1;

};

block();

NSLog(@"val = %ld", val);

}

return 0;

}

使用_rewrite_objc展开

struct __Block_byref_val_0 {

void *__isa;

__Block_byref_val_0 *__forwarding;

int __flags;

int __size;

NSInteger val;

};

struct __main_block_impl_0 {

struct __block_impl impl;

struct __main_block_desc_0* Desc;

__Block_byref_val_0 *val; // by ref

__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_val_0 *_val, int flags=0) : val(_val->__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_byref_val_0 *val = __cself->val; // bound by ref

(val->__forwarding->val) = 1;

}

static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->val, (void*)src->val, 8/*BLOCK_FIELD_IS_BYREF*/);}

static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->val, 8/*BLOCK_FIELD_IS_BYREF*/);}

static struct __main_block_desc_0 {

size_t reserved;

size_t Block_size;

void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*);

void (*dispose)(struct __main_block_impl_0*);

} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0), __main_block_copy_0, __main_block_dispose_0};

int main(int argc, const char * argv[]) {

/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;

__attribute__((__blocks__(byref))) __Block_byref_val_0 val = {(void*)0,(__Block_byref_val_0 *)&val, 0, sizeof(__Block_byref_val_0), 0};

void(*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_val_0 *)&val, 570425344));

((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);

NSLog((NSString *)&__NSConstantStringImpl__var_folders_2h_70k4gzp53qn7ytk0cdjr9kk80000gn_T_main_7eb9e7_mi_0,(val.__forwarding->val));

}

return 0;

这次转码后似乎比刚才多了些东西,仔细看下,

一个是__Block_byref_val_0的结构体以及两个方法static void __main_block_copy_0和static void __main_block_dispose_0; 后面的两个方法先暂且不关注(后面会涉及)。

其实结构体__Block_byref_val_0产生的实例就是我们使用__block修饰过的变量。

struct __Block_byref_val_0 {

void *__isa;

__Block_byref_val_0 *__forwarding;

int __flags;

int __size;

NSInteger val;

};

从该结构体声明可以看出,这个结构体中包含了该实例本身的引用 __forwarding。

我们从上述被转化的代码中可以看出 Block 本身也一样被转换成了__main_block_impl_0结构体实例,该实例持有__Block_byref_val_0结构体实例的指针。

我们再看一下Block实现和调用部分代码被转化后的结果:

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {

__Block_byref_val_0 *val = __cself->val; // bound by ref

(val->__forwarding->val) = 1;

}

((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);

不难发现从__cself找到__Block_byref_val_0结构体实例,然后通过该实例的__forwarding访问成员变量val。成员变量val是该实例自身持有的变量,指向的是原来的局部变量。

详情参见下图:

__block.jpg

至此,已经展示了__block变量在Block中查找和修改的过程,那么:

当Block作为回调执行时,局部变量val已经出栈了,这个时候代码为什么还能正常工作呢?

我们为什么通过成员变量__forwarding而不是直接去访问结构体中我们需要修改的变量呢?

我们在上述转换过的代码中可以发现__main_block_impl_0结构体构造函数中,isa指针指向的是_NSConcreteStackBlock; 而Block还有另外两个与之相似的类:

_NSConcreteGlobalBlock //全局的静态block 不会访问任何外部变量

_NSConcreteMallocBlock //保存在堆区的,引用计数为0时会被销毁。

_NSConcreteStackBlock //保存在栈区,出栈后被销毁

上述示例代码中,Block是被设为_NSConcreteStackBlock,在栈上生成。当我们把Block作为全局变量使用时,对应生成的Block将被设为_NSConcreteGlobalBlock

void (^block)(void) = ^{NSLog(@"This is a Global Block");};

int main(int argc, const char * argv[]) {

@autoreleasepool {

block();

}

return 0;

}

该代码转码c++后,Block结构体的isa指针初始化时如下:

impl.isa = &_NSConcreteGlobalBlock;

那_NSConcreteMallocBlock何时被使用

分配在全局变量上的Block,在变量作用域外也可以通过指针安全的访问。

但分配在栈上的Block,如果它所属的变量作用域结束,该Block就被废弃。同样,__block变量也分配在栈上,当超过该变量的作用域时,该__block变量也会被废弃。

此时,就需要使用_NSConcreteMallocBlock,OC中提供了将Block和__block变量从栈上复制到堆上的方法,将分配到栈上的Block复制到堆上,这样当栈上的Block超过它原本作用域时,堆上的Block还可以继续存在。

复制到堆上的Block,它的结构体成员变量isa将变为:

impl.isa = &_NSConcreteMallocBlock;

而_block变量中结构体成员__forwarding就在此时保证了从栈上复制到堆上能够正确访问__block变量。在这种情况下,只要栈上的_block变量的成员变量__forwarding指向堆上的实例,我们就能够正确访问。

我们一般可以使用copy方法手动将 Block 或者 __block变量从栈复制到堆上。比如我们把Block做为类的属性访问时,我们一般把该属性设为copy。有些情况下我们可以不用手动复制,比如Cocoa框架中使用含有usingBlock方法名的方法时,或者GCD的API中传递Block时。

当一个Block从栈复制到堆中,与之相关的__block变量也会被复制到堆中。此时堆中的Block持有相应堆上的__block变量,当堆上的__block变量没有持有者,才会被释放。

而在栈上的__block变量被复制到堆上之后,会将成员变量__forwarding的值替换为堆上的__block变量的地址。这个时候我们可以通过以下代码访问:

val.__forwarding->val

如下图:

__block变量和循环引用问题

__block修饰符可以指定任意类型的局部变量。此时还记这两个方法吗?

static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src {     _Block_object_assign((void*)&dst->val, (void*)src->val, 8/*BLOCK_FIELD_IS_BYREF*/); } static void __main_block_dispose_0(struct __main_block_impl_0*src) {     _Block_object_dispose((void*)src->val, 8/*BLOCK_FIELD_IS_BYREF*/); }

当Block从栈复制到堆时,会调用_Block_object_assign函数持有该变量(相当于retain);

当堆上的Block被废弃时,会调用_Block_object_dispose函数释放该变量(相当于release)。

由上文描述可知,我们可以使用下述代码解除Block循环引用的问题:

__block id tmp = self;

void(^block)(void) = ^{

tmp = nil;

};

block();

通过执行block方法,nil被赋值到_block变量tmp中。这个时候_block变量对 self 的强引用失效,从而避免循环引用的问题。

总结:

通过__block变量可以控制对象的生命周期,在不能使用__weak修饰符的环境中,我们可以避免使用__unsafe_unretained修饰符。

在执行Block时可动态地决定是否将nil或者其它对象赋值给__block变量。

但是这种方法有一个明显的缺点就是,我们必须去执行Block才能够解除循环引用问题,否则就会出现问题。

4. 比较__weak 和 __strong

这边用AFN中的一段代码

__weak __typeof(self)weakSelf = self;

AFNetworkReachabilityStatusBlock callback = ^(AFNetworkReachabilityStatus status) {

__strong __typeof(weakSelf)strongSelf = weakSelf;

strongSelf.networkReachabilityStatus = status;

if (strongSelf.networkReachabilityStatusBlock) {

strongSelf.networkReachabilityStatusBlock(status);

}

};

1. __weak

我们在使用Block时,有时候会用到self,而Block内部对self默认都是强引用。在ARC下,编译器将Block从栈区拷贝到堆区,Block会强引用和持有self,而self 也会强引用和持有Block,于是就造成了循环引用。

此时就需要使用__weak,在修饰变量时,修饰符修饰变量self,让 block 不强引用self,从而破除循环。

__weak typeof(self) weakSelf = self;

self.passValueBlock = ^(NSString *string){

dispatch_async(dispatch_get_main_queue(), ^{

weakSelf.pointView.startLabel.text = string;

});

};

弱引用不会影响对象释放,当一个对象被释放是,所有指向它的弱引用会被置空,也避免出现野指针。

2. __strong

上面提到,__weak很好的解决retain Cycle,但还是会存在一些隐患。不知道self什么时候被释放,为了保证在Block内部不会被释放,所以使用__strong修饰。

看下一段测试代码

在ViewController添加属性

@property (nonatomic, strong) ViewController *vc;

viewDidLoad中

ViewController *vc = [[ViewController alloc] init];

self.vc = vc;

__weak ViewController * weakVC = self.vc;

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

NSInteger count = 0;

while (count < 4) {

count++;

NSLog(@"%@",weakVC);

sleep(1);

}

});

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{

self.vc = nil;

});

实现dealloc方法

- (void)dealloc {

NSLog(@"%@",[self class]);

}

看输出结果:

2016-06-20 15:12:27.797 __strongTest[14823:1753981] 

2016-06-20 15:12:28.802 __strongTest[14823:1753981] 

2016-06-20 15:12:29.797 __strongTest[14823:1753934] ViewController

2016-06-20 15:12:29.804 __strongTest[14823:1753981] (null)

2016-06-20 15:12:30.808 __strongTest[14823:1753981] (null)

可以看出:Block内部的对self.vc是弱引用。当2s后,self.vc在外部被释放,则Block内部对self.vc的持有也失效。

现在在Block内部对self.vc进行强引用,Block内部代码调整为:

__strong ViewController *strongVC = weakVC;

NSInteger count = 0;

while (count < 4)

count++;

NSLog(@"%@",strongVC);

sleep(1);

}

再看输出结果:

2016-06-20 15:22:38.423 __strongTest[14839:1762881] 

2016-06-20 15:22:39.424 __strongTest[14839:1762881] 

2016-06-20 15:22:40.429 __strongTest[14839:1762881] 

2016-06-20 15:22:41.430 __strongTest[14839:1762881] 

2016-06-20 15:22:42.431 __strongTest[14839:1762835] ViewController

Block内部对对象采用strong修饰后,既使原持有对象在block外部已经被释放,但Block内部扔能持有,于是执行完Block后,该对象才被dealloc。

总结:weakSelf是为了Block不持有self,避免循环引用,而再声明一个strongSelf是因为一旦进入Block执行,就不允许self在这个执行过程中释放。Block执行完后这个strongSelf会自动释放,没有循环引用问题。

最后,使用Block时的注意事项

1.Block内部不能直接修改局部变量

Block内部可以访问外部的变量, 默认是将其拷贝到其数据结构中来实现访问的, 属性是只读的. Block内部不能修改外面的局部变量.

如果要修改需要对要修改的局部变量用__block修饰, 这样局部变量就可以在Block内部修改了,Block是复制其引用地址来实现访问的

2.当Block里面的出现self,造成的循环引用

循环引用就是当self 拥有一个Block的时候,在Block中又调用self的方法。形成了你中有我,我中有你,造成谁都无法将谁释放。从而发生内存泄漏。

解决方法:

__weak typeof (self) weakSelf = self;

定义一个weakSelf变量并加上__weak修饰符,在Block代码块中,所有需要self的地方都用weakSelf来替代。这样就不会增加引用计数,所以Block持有self对象也就不会造成循环引用,从而避免内存泄漏。

参考

Objective-C中的Block

Objective-C中Block的存储域

__block &__weak & __strong

Objective-C 高级编程: iOS和OS X多线程和内存管理

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏Dawnzhang的开发者手册

数据结构与算法学习笔记之后进先出的“桶”

1.“后进先出,先进后出”的数据结构。 2.从操作特性来看,是一种“操作受限”的线性表,只可以在一端插入和删除数据。

752
来自专栏木木玲

Reference 、ReferenceQueue 详解

2977
来自专栏程序员Gank

《Objective-C-高级编程》干货三部曲(二):Blocks篇

这一章讲解了Block相关的知识。因为作者将Objective-C的代码转成了C++的代码,所以第一次看的时候非常吃力,我自己也不记得看了多少遍了。

1211
来自专栏進无尽的文章

编码篇-Block里面的小天地

Block是iOS4.0+ 和Mac OS X 10.6+ 引进的对C语言的扩展,用来实现匿名函数的特性。 通常来说,block都是一些简短代码片段的封装,适...

1162
来自专栏静晴轩

Lua代码片段收集

Lua实现闭包 --[[@Func :实现闭包 @Desc : 当一个函数内部嵌套另一个函数定义时,内部的函数体可以访问外部的函数的局部变量,这种特征...

3275
来自专栏老九学堂

十七个C语言新手编程时常犯的错误及解决方式

C编译的程序对语法检查并不像其它高级语言那么严格,这就给编程人员留下“灵活的余地”,但还是由于这个灵活给程序的调试带来了许多不便,尤其对初学C语言的人来说,经常...

2967
来自专栏黑白安全

PHP中函数和语言结构的区别

关于PHP中的函数和语言结构的区别,本文给大伙逐步分析。函数众所周知它的三要素为:函数名、参数、返回值,调用方式采用函数名加括号()的形式进行调用。语言结构可以...

1242
来自专栏xingoo, 一个梦想做发明家的程序员

剑指OFFER之用两个栈实现队列(九度OJ1512)

题目描述: 用两个栈来实现一个队列,完成队列的Push和Pop操作。 队列中的元素为int类型。 输入: 每个输入文件包含一个测试样例。 对于每个测试样例,第一...

1946
来自专栏大壮

iOS block的一些理解和注意点

1734
来自专栏码云1024

python简明笔记

通过 for 语句我们可以使用 for 循环。Python 里的 for 循环与 C 语言中的不同。这里的 for 循环遍历任何序列(比如列表和字符串)中的每一...

5779

扫码关注云+社区