iOS开发之block（二）

之前的文章中介绍了关于block的定义和使用。这篇文章主要介绍跟block的内存管理的有关知识。重点介绍block在使用内部变量、外部变量和ARC、非ARC的情况下的使用，以及block引发的循环引用问题。

根据Block在内存中的位置分为三种类型NSGlobalBlock，NSStackBlock, NSMallocBlock。（知道就行）

<1>NSGlobalBlock：类似函数，位于text段；

<2>NSStackBlock：位于栈内存，函数返回后Block将无效；

<3>NSMallocBlock：位于堆内存。

使用内部变量在ARC和非ARC条件下：

对于没有引用外部变量的Block，无论在ARC还是非ARC下，类型都是__NSGlobalBlock__，这种类型的block可以理解成一种全局的block，不需要考虑作用域问题。同时，对block进行Copy或者Retain操作也是无效的，

typedef int(^MyBlock)();MyBlock func() {    return ^{ return 123; };}// 在非ARC下执行如下代码：- (void)test {   MyBlock block = func();   NSLog(@"%d", block());   NSLog(@"%@", [block class]);   MyBlock block2 = [block copy];   //Copy操作对__NSGlobalBlock__类型无效   NSLog(@"%d", block == block2);}

输出：

123

__NSGlobalBlock__

1

可以看到，copy后的block和原来是同一个对象的。

使用外部变量在ARC条件下：

对于引用了外部变量的block，如果没有对他进行copy，它的作用域只会在声明它的函数栈内（类型是__NSStackBlock__），如果在ARC下直接返回此类block是正确的，因为在ARC下，系统会自动添加copy，如下：

typedef int(^MyBlock)();MyBlock func() {    int i = 123;    return ^{ return i; };// 此处block使用了外部变量i}// 在非ARC下执行如下代码：void test() {    MyBlock block = func();    NSLog(@"%d", block());    NSLog(@"%@", [block class]);}

输出：

123

__NSMallocBlock__

类型是__NSMallocBlock__，说明block已经被copy到了堆中了。

使用外部变量在非ARC条件下：

block内使用外部变量，在非ARC下编译会直接报错（Xcode提示Returningblock that lives on the local stack），因为此时block还在栈中，不能执行retain操作。

当然其实在非ARC下，也可以使上面的情况编译通过，如下

typedef int(^MyBlock)();MyBlock func(){    int i = 123;    //非ARC下不要这样！！！    MyBlock ret = ^{ return i; };    return ret;}

我们把原来的返回值赋给一个变量，然后再返回这个变量，就可以编译通过了。不过虽然编译通过了，这个返回的block作用域仍是在函数栈中的，因此一旦函数运行完毕后再使用这个block很可能会引发BAD_ACCESS错误。

所以在非ARC下，必须把block复制到堆中才可以在函数外使用，或使用外部变量，如下：

typedef int(^MyBlock)();MyBlock func(){    //非ARC    int i = 123;    return [^{ return i; } copy];}

block修改外部变量的值

block使用外部变量，并不对它修改的时候，一般来说，block 只是将变量值复制过来的。而当我们用__block标记的时候，被标记__block的变量事实上应该说是被移动到了堆上。表示在 block 中的修改对于 block 外也是有效地。（ARC和非ARC是一样的）

下面总结一下block被copy后，它所引用的变量被复制到了堆中的情况，如下代码（非ARC下）：

//非ARCvoid func(){    int a = 123;    __block int b = 123;    NSLog(@"%@", @"=== block copy前");    NSLog(@"&a = %p, &b = %p", &a, &b);        void(^block)() = ^{        NSLog(@"%@", @"=== Block");        NSLog(@"&a = %p, &b = %p", &a, &b);        NSLog(@"a = %d, b = %d", a, b = 456);    };    block = [block copy];    block();        NSLog(@"%@", @"=== block copy后");    NSLog(@"&a = %p, &b = %p", &a, &b);    NSLog(@"a = %d, b = %d", a, b);        [block release];}

输出：

=== block copy前

&a = 0x7fff5fbff8bc, &b = 0x7fff5fbff8b0

=== Block

&a = 0x100201048, &b = 0x100201068

a = 123, b = 456

=== block copy后

&a = 0x7fff5fbff8bc, &b = 0x100201068

a = 123, b = 456

可以看到，在block执行中，他所引用的变量a和b都被复制到了堆上。因此，当block执行后，函数栈内访问被__block标记的b的时候，b的地址会变成堆中的地址。而变量a，仍会指向函数栈内原有的变量a的空间。

循环引用

只要对象没有强指针指向它，它就会被释放，最后被销毁。

前面说过，使用block不管在ARC还是非ARC ，都必须使用copy将block复制到堆中。但block在copy时都会对block内部用到的对象进行强引用(ARC)或者retainCount增1(非ARC)。在ARC与非ARC环境下对block使用不当都会引起循环引用问题。

一般表现为：某个类将block作为自己的属性变量，然后该类在block的方法体里面又使用了该类本身。如下图：

block的这种循环引用会被编译器捕捉到并及时提醒。

网上大部分帖子都表述为"block里面引用了self导致循环引用"，但事实真的是如此吗？其实这种说法是不严谨的，不一定要显式地出现"self"字眼才会引起循环引用。我们改一下代码，不通过属性self去访问变量，而是通过实例变量_去访问，如下：

很明显了：

即使在你的block代码中没有显式地出现"self"，也会出现循环引用！只要你在block里用到了self所拥有的东西！就有可能引发循环引用。

循环引用使得两者都无法释放，导致内存泄露。解决思想：可以将其中一个声明为弱指针，这样就可以避免循环引用问题。

ARC

__weak typeof(self)  weakSelf=self; // 其实 __weak someClass *weakSelf = self也是OK的！！！__block typeof(self)  blockSelf=self; // 其实 __block someClass*blockSelf = self也是OK的！！！

非ARC

__block typeof(self)  blockSelf=self; // 其实 __block someClass *blockSelf = self也是OK的！！！

__block和__weak修饰符的区别其实是挺明显的：

1.__block不管是ARC还是MRC模式下都可以使用，可以修饰对象，还可以修饰基本数据类型。

2.__weak只能在ARC模式下使用，也只能修饰对象（如：NSString），不能修饰基本数据类型（如：int）。

3.__block对象可以在block中被重新赋值，__weak不可以。

PS：__unsafe_unretained修饰符可以被视为iOSSDK 4.3以前版本的__weak的替代品，不过不会被自动置空为nil。所以尽可能不要使用这个修饰符。

看下面的例子（ARC）：

定义一个HXTool工具类，如下：

#import <Foundation/Foundation.h>typedef void (^blockOperation)();@interface HXTool : NSObject@property (nonatomic, copy) blockOperation operation;// 执行打印操作@end

在控制器view中，ViewController.m

#import "ViewController.h"#import "HXTool.h"@interface ViewController ()@property (nonatomic, strong) HXTool *tool;@property (nonatomic, assign) int age;@end@implementation ViewController- (void)viewDidLoad {    [super viewDidLoad];    HXTool *tool = [[HXTool alloc] init];    self.tool = tool;}- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {    self.tool.operation = ^(){        self.age ++;        NSLog(@"age = %d", self.age);    };    self.tool.operation();}@end

上面写法对应ViewController和HXTool的关系：

每个对象都有强指针引用着，谁也释放不了，导致循环引用。

将self声明为__blockViewController *vc = self;或者 __weak ViewController *vc = self;则关系变成下图：

（上面2张图中实线代表强引用，虚线代表弱引用）

由于self被声明为弱引用，block不会再对它进行强制引用，当不在使用self的时候，由于没有强引用引用它，所有它可以被释放掉，这样就不会循环引用。

 

retain cycle问题的根源在于Block和obj可能会互相强引用，互相retain对方，这样就导致了retaincycle，最后这个Block和obj就变成了孤岛，谁也释放不了谁。

解决：将其中一个声明为弱指针即可。