美文网首页
block的内存管理与多线程

block的内存管理与多线程

作者: 彡廿 | 来源:发表于2016-06-14 12:37 被阅读180次

    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 与变量
    

    import "ViewController.h"

    import "Person.h"

    @interface ViewController ()

    @end

    // 全局变量
    int globalVar = 12;

    @implementation ViewController

    • (void)viewDidLoad {
      [super viewDidLoad];

      Person * person = [[Person alloc] init];

      // 静态变量
      static int staticVar = 11;

      // 局部变量
      __block int tempVar = 10;

      // 局部指针变量 arr str
      __block NSArray * arr = @[@1,@2,@3,@4];
      __block NSString * str = @"1234";

      // 局部指针变量
      NSMutableArray * arr1 = [NSMutableArray array];

      NSLog(@"tempVar = %d,globalVar = %d,staticVar = %d\n arr = %@\nstr = %@\narr1 = %@",tempVar,globalVar,staticVar,arr,str,arr1);
      NSLog(@"--------------------------");
      person.block = ^{
      // 加了__block 之后这个局部变量就可以在 block 内部修改值了
      // 修改了 tempVar 的值
      tempVar = 20;

        // 修改了 arr 指针的值
        arr = @[@1];
        
        // 修改了 str 指针的值
        str = @"12";
        
        // 全局变量不用加__block 就可以修改
        globalVar = 22;
        
        // 静态变量不用加__block 也可以修改
        staticVar = 21;
        
        // 局部指针变量(这个有一点难度):只是更改了指针指向的内容值,而没有改变指针的值,所以这个是不用加 __block 的
        [arr1 addObject:@1];
      

      };

      person.block();

      NSLog(@"tempVar = %d,globalVar = %d,staticVar = %d\n arr = %@\nstr = %@\narr1 = %@",tempVar,globalVar,staticVar,arr,str,arr1);
      // 可以访问局部变量,但是不能修改,因为 block 捕获的外部的局部变量在 block 内部是const 的,所以不能修改,想要修改只能在局部变量前加__block
      }
      @end```

    打印结果:

    11.png
    结论:

    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 类

    #import <Foundation/Foundation.h>
    @interface Person : NSObject
    @property (nonatomic,copy) NSString * name;
    @property (nonatomic,copy) void(^block)();
    @end```
    
    在 viewcontroller.m
    
    • (void)viewDidLoad {
      [super viewDidLoad];
      Person * person = [[Person alloc] init];
      person.name = @"joke";
      person.block = ^{
      NSLog(@"%@",person.name);
      };
      }```

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

    strong.png

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

    - (void)viewDidLoad {
        [super viewDidLoad];
        Person * person = [[Person alloc] init];
        __weak typeof(Person) *weakPerson = person;
        person.name = @"joke";
        person.block = ^{
            NSLog(@"%@",weakPerson.name);
        };
    }```
    #####5.1、总结:
    1、block 内部使用了外部声明的强引用访问对象A,那么 block 内部会自动产生一个强引用指向对象 A
    2、block 内部使用了外部声明的弱引用访问对象A,那么 block 内部会自动产生一个弱引用指向对象 A
    
    #####5.2、当 block 遇到了多线程
    
    上面讲述了为了避免循环强引用,在 block 内部使用外部用__weak 修饰的弱引用。我们知道弱引用指向的对象在没有强引用引用的时候就会自动销毁,同时弱引用的指针赋值为 nil。那么如果在 block 里面使用了多线程来访问弱引用,因多线程执行的时间顺序不定,会造成在多线程访问对象的时候这个弱引用的对象已经销毁了。
    
    bug 代码:
    
    • (void)viewDidLoad {
      [super viewDidLoad];
      Person * person = [[Person alloc] init];

      // 弱引用对象
      __weak typeof(Person) *weakPerson = person;
      person.name = @"joke";

      person.block = ^{
      // 开辟一条线程
      dispatch_async(dispatch_get_global_queue(0, 0), ^{
      // 访问弱引用的对象
      NSLog(@"name = %@",weakPerson.name);
      });
      };
      person.block();
      }```
      打印结果:

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

    解决方案:

    - (void)viewDidLoad {
        [super viewDidLoad];
        Person * person = [[Person alloc] init];
        
        // 弱引用对象
        __weak typeof(Person) *weakPerson = person;
        person.name = @"joke";
        
        NSLog(@"%p",&person);
        
        person.block = ^{
            
            __strong typeof(Person) * strongPerson = weakPerson;
            
            // 开辟一条线程
            dispatch_async(dispatch_get_global_queue(0, 0), ^{
                // 访问弱引用的对象
                NSLog(@"name = %@",strongPerson.name);
            });
            
            NSLog(@"strongp = %p,weakp = %p",&strongPerson,&weakPerson);
        };
        person.block();
    }```
    打印结果:
    
    ![6.png](https://img.haomeiwen.com/i854488/f57f48397b59fc51.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
    这时会有同学疑问,外部不用弱引用不就行了,干么还要通过一次弱引用的传递啊。如果那样的话,就会产生上面讲述的循环强引用,中间的的弱引用的作用就是传递一次对象的地址,别无它用!不通过弱引用直接使用的,用的是同一个强指针,通过弱引用的传递,是两个不同的强指针指向同一对象。
    
    ![10.png](https://img.haomeiwen.com/i854488/356b5c7f0a59531b.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
    ####6、`__block` 和`__weak`修饰符的区别:
    1.`__block`不管是ARC还是MRC模式下都可以使用,可以修饰对象,还可以修饰基本数据类型。
    2.`__weak`只能在ARC模式下使用,也只能修饰对象(NSString),不能修饰基本数据类型(int)。
    3.`__block`对象可以在block中被重新赋值,`__weak`不可以。
    PS:`__unsafe_unretained`修饰符可以被视为iOS SDK 4.3以前版本的`__weak`的替代品,不过不会被自动置空为nil。所以尽可能不要使用这个修饰符。
    

    相关文章

      网友评论

          本文标题:block的内存管理与多线程

          本文链接:https://www.haomeiwen.com/subject/bxludttx.html