block 的内存管理与多线程

最新推荐文章于 2024-03-27 23:46:27 发布

a1230302

最新推荐文章于 2024-03-27 23:46:27 发布

阅读量121

点赞数

原文链接：http://www.cnblogs.com/fadh/p/5582605.html

版权

1、block 的概述：

我们知道，block 主要用于实现的代理的一些功能，用于两个类之间值的传递，以及实现链式编程，降低代码的碎片的功能。

2、block 的声明和定义：

// 1、属性：返回类型（^变量名）（参数类型列表）
@property (nonatomic, copy, nullability) returnType (^blockName)(parameterTypes);

// 2、方法参数： 返回类型（^）（参数类型列表）参数名
- (void)someMethodThatTakesABlock:(returnType (^nullability)(parameterTypes))blockName;

// 3、作为参数去调用：^返回类型（参数列表）{//实现}
[someObject someMethodThatTakesABlock:^returnType (parameters) {...}];

// 4、重定义：返回类型(^类型名)（参数类型列表）
typedef returnType (^TypeName)(parameterTypes);
TypeName blockName = ^returnType(parameters) {...};

// 5、局部变量：就是定义和实现
returnType (^blockName)(parameterTypes) = ^returnType(parameters) {...};

3、block 与变量

 1 #import "ViewController.h"
 2 #import "Person.h"
 3 
 4 @interface ViewController ()
 5 
 6 @end
 7 
 8 // 全局变量
 9 int globalVar = 12;
10 
11 @implementation ViewController
12 
13 - (void)viewDidLoad {
14     [super viewDidLoad];
15     
16     Person * person = [[Person alloc] init];
17     
18     // 静态变量
19     static int staticVar = 11;
20     
21     // 局部变量
22     __block int tempVar = 10;
23     
24     // 局部指针变量 arr str
25     __block NSArray * arr = @[@1,@2,@3,@4];
26     __block NSString * str = @"1234";
27     
28     // 局部指针变量
29     NSMutableArray * arr1 = [NSMutableArray array];
30     
31     NSLog(@"tempVar = %d,globalVar = %d,staticVar = %d\n arr = %@\nstr = %@\narr1 = %@",tempVar,globalVar,staticVar,arr,str,arr1);
32     NSLog(@"--------------------------");
33     person.block = ^{
34         //  加了__block 之后这个局部变量就可以在 block 内部修改值了
35         // 修改了 tempVar 的值
36         tempVar = 20;
37         
38         // 修改了 arr 指针的值
39         arr = @[@1];
40         
41         // 修改了 str 指针的值
42         str = @"12";
43         
44         // 全局变量不用加__block 就可以修改
45         globalVar = 22;
46         
47         // 静态变量不用加__block 也可以修改
48         staticVar = 21;
49         
50         // 局部指针变量（这个有一点难度）：只是更改了指针指向的内容值，而没有改变指针的值，所以这个是不用加 __block 的
51         [arr1 addObject:@1];
52 
53     };
54 
55     person.block();
56     
57     NSLog(@"tempVar = %d,globalVar = %d,staticVar = %d\n arr = %@\nstr = %@\narr1 = %@",tempVar,globalVar,staticVar,arr,str,arr1);
58     // 可以访问局部变量，但是不能修改，因为 block 捕获的外部的局部变量在 block 内部是const 的，所以不能修改，想要修改只能在局部变量前加__block
59 }
60 
61 
62 @end

打印结果：

结论：

1、block 与局部变量：block 可以访问外部的局部变量，就像 arr1, 但是不能修改局部变量的值，想要修改值就必须加上__block。

2、block 与全局变量和静态变量：block 可以直接访问并修改局部变量的值。

4、block 与 copy 属性

block 的内存是分配在栈上的，栈上的东西，在不需要的时候系统会自动收回，如果 block内部强引用了外部的一些变量，就会造成内存的泄露，此时 copy 的左右就是把栈上分配的 block 拷贝到堆上。但是在 ARC 模式下 block 的 copy 属性系统会自动添加的。

5、block 与循环强引用

一个强引用对象 A强引用block，block内部又捕获到了外部的强引用A，就会引起循环强引用。

比如：person 类

1 #import <Foundation/Foundation.h>
2 @interface Person : NSObject
3 @property (nonatomic,copy) NSString * name;
4 @property (nonatomic,copy) void(^block)();
5 @end

在 viewcontroller.m

1 - (void)viewDidLoad {
2     [super viewDidLoad];
3     Person * person = [[Person alloc] init];
4     person.name = @"joke";
5     person.block = ^{
6         NSLog(@"%@",person.name);
7     };
8 }

在这里，person强引用着block对象，block内部又强引用了person对象，造成了循环强引用。

为了避免内存泄露只能将 block 外部的 person 强引用对像赋值一个弱引用(__weak)

1 - (void)viewDidLoad {
2     [super viewDidLoad];
3     Person * person = [[Person alloc] init];
4     __weak typeof(Person) *weakPerson = person;
5     person.name = @"joke";
6     person.block = ^{
7         NSLog(@"%@",weakPerson.name);
8     };
9 }

5.1、总结：

1、block 内部使用了外部声明的强引用访问对象A，那么 block 内部会自动产生一个强引用指向对象 A

2、block 内部使用了外部声明的弱引用访问对象A，那么 block 内部会自动产生一个弱引用指向对象 A

5.2、当 block 遇到了多线程

上面讲述了为了避免循环强引用，在 block 内部使用外部用__weak 修饰的弱引用。我们知道弱引用指向的对象在没有强引用引用的时候就会自动销毁，同时弱引用的指针赋值为 nil。那么如果在 block 里面使用了多线程来访问弱引用，因多线程执行的时间顺序不定，会造成在多线程访问对象的时候这个弱引用的对象已经销毁了。

bug 代码：

 1 - (void)viewDidLoad {
 2     [super viewDidLoad];
 3     Person * person = [[Person alloc] init];
 4     
 5     // 弱引用对象
 6     __weak typeof(Person) *weakPerson = person;
 7     person.name = @"joke";
 8     
 9     person.block = ^{
10         // 开辟一条线程
11         dispatch_async(dispatch_get_global_queue(0, 0), ^{
12             // 访问弱引用的对象
13             NSLog(@"name = %@",weakPerson.name);
14         });
15     };
16     person.block();
17 }

打印结果：

结果显示：在子线程中去访问弱引用时，弱引用已经被销毁，这时的解决办法就是在 block 内部重新生成一个外部对象的强应用

解决方案：

 1 - (void)viewDidLoad {
 2     [super viewDidLoad];
 3     Person * person = [[Person alloc] init];
 4     
 5     // 弱引用对象
 6     __weak typeof(Person) *weakPerson = person;
 7     person.name = @"joke";
 8     
 9     NSLog(@"%p",&person);
10     
11     person.block = ^{
12         
13         __strong typeof(Person) * strongPerson = weakPerson;
14         
15         // 开辟一条线程
16         dispatch_async(dispatch_get_global_queue(0, 0), ^{
17             // 访问弱引用的对象
18             NSLog(@"name = %@",strongPerson.name);
19         });
20         
21         NSLog(@"strongp = %p,weakp = %p",&strongPerson,&weakPerson);
22     };
23     person.block();
24 }