iOS-Block 浅谈

前言:Block 是开发过程中常用便捷的回调方式,本文简单介绍 Block

一、Block 简介

Block 对象是 C 级别的语法和运行时特性,和标准的 C 函数类似,除了可执行代码外,还可能包含变量自动绑定(栈)和内存托管(堆)。一个 Block 维护一个状态集。
闭包 = 一个函数「或指向函数的指针」+ 该函数执行的外部的上下文变量「也就是自由变量」;Block 是 Objective-C 对于闭包的实现。

  • 可以嵌套定义,定义 Block 方法和定义函数方法相似
  • Block 可以定义在方法内部或外部
  • 只有调用 Block 时候,才会执行其{}体内的代码
  • 本质是对象,使代码高聚合

使用 clang 将 OC 代码转换为 C++ 文件查看 block 的方法:

  • 在命令行输入代码 clang -rewrite-objc 需要编译的OC文件.m
  • 这时查看当前的文件夹里 多了一个相同的名称的 .cpp 文件,在命令行输入 open main.cpp 查看文件

1.1 定义和使用

1.无参数无返回值

void (^ MyBlockOne)(void) = ^(void){
    NSLog(@"无参数,无返回值");  
};  
MyBlockOne();//block的调用

2.有参数无返回值

void(^MyblockTwo)(int a) = ^(int a){
    NSLog(@"@ = %d我就是block,有参数,无返回值",a);
};  
MyblockTwo(100);

3.有参数有返回值

int(^MyBlockThree)(int,int) = ^(int a,int b){    
    NSLog(@"%d我就是block,有参数,有返回值",a + b);
    return a + b; 
};  
MyBlockThree(12,56);

4.无参数有返回值

int(^MyblockFour)(void) = ^{
    NSLog(@"无参数,有返回值");
    return45;
  };
MyblockFour();

5.定义声明

声明

typedef void (^Block)();
typedef int (^MyBlock)(int , int);
typedef void(^ConfirmBlock)(BOOL isOK);
typedef void(^AlertBlock)(NSInteger alertTag);

定义属性

@property (nonatomic,copy) MyBlock myBlockOne;

使用

self.myBlockOne = ^int (int ,int){
    //TODO
}

1.2 Block与外界变量

1、截获自动变量(局部变量)值

(1)默认情况
对于 block 外的变量引用,block 默认是将其复制到其数据结构中来实现访问的。也就是说block的自动变量截获只针对block内部使用的自动变量, 不使用则不截获, 因为截获的自动变量会存储于block的结构体内部, 会导致block体积变大。特别要注意的是默认情况下block只能访问不能修改局部变量的值。

int age = 10;
myBlock block = ^{
    NSLog(@"age = %d", age);
};
age = 18;
block();

输出结果:
age = 10

(2) __block 修饰的外部变量

对于用 __block 修饰的外部变量引用,block 是复制其引用地址来实现访问的。block可以修改__block 修饰的外部变量的值。

__block int age = 10;
myBlock block = ^{
    NSLog(@"age = %d", age);
};
age = 18;
block();

输出为:
age = 18

2、__block 修饰的外部变量的值就可以被block修改

我们使用 clang 将 OC 代码转换为 C++ 文件:

clang -rewrite-objc 源代码文件名
__block int val = 10;
转换成
__Block_byref_val_0 val = {
    0,
    &val,
    0,
    sizeof(__Block_byref_val_0),
    10
};

会发现一个局部变量加上__block修饰符后竟然跟block一样变成了一个__Block_byref_val_0结构体类型的自动变量实例。
此时我们在block内部访问val变量则需要通过一个叫__forwarding的成员变量来间接访问val变量。

1.3 Block 存储

1、Block的存储域及copy操作

由C/C++/OBJC编译的程序占用内存分布的结构:


内存分布结构

block有三种类型:

  • 全局块(_NSConcreteGlobalBlock)
  • 栈块(_NSConcreteStackBlock)
  • 堆块(_NSConcreteMallocBlock)

三种block各自的存储域:

  • 全局块存在于全局内存中, 相当于单例.
  • 栈块存在于栈内存中, 超出其作用域则马上被销毁
  • 堆块存在于堆内存中, 是一个带引用计数的对象, 需要自行管理其内存
block存储域

简而言之,存储在栈中的Block就是栈块、存储在堆中的就是堆块、既不在栈中也不在堆中的块就是全局块。

1.4 判断Block的存储位置

(1)Block不访问外界变量(包括栈中和堆中的变量)
Block 既不在栈又不在堆中,在代码段中,ARC和MRC下都是如此。此时为全局块。
(2)Block访问外界变量
MRC 环境下:访问外界变量的 Block 默认存储中。
ARC 环境下:访问外界变量的 Block 默认存储在中(实际是放在栈区,然后ARC情况下自动又拷贝到堆区),自动释放。

ARC下,访问外界变量的 Block为什么要自动从栈区拷贝到堆区呢?
栈上的Block,如果其所属的变量作用域结束,该Block就被废弃,如同一般的自动变量。当然,Block中的__block变量也同时被废弃。
为了解决栈块在其变量作用域结束之后被废弃(释放)的问题,我们需要把Block复制到堆中,延长其生命周期。开启ARC时,大多数情况下编译器会恰当地进行判断是否有需要将Block从栈复制到堆,如果有,自动生成将Block从栈上复制到堆上的代码。Block的复制操作执行的是copy实例方法。Block只要调用了copy方法,栈块就会变成堆块。

栈块copy堆块

  • 在ARC的Block是配置在栈上的,所以返回函数调用方时,Block变量作用域就结束了,Block会被废弃。种情况编译器会自动完成复制。
  • 在非ARC情况下则需要开发者调用copy方法手动复制。
  • 将Block从栈上复制到堆上相当消耗CPU,所以当Block设置在栈上也能够使用时,就不要复制了,因为此时的复制只是在浪费CPU资源。

Block的复制操作执行的是copy实例方法。不同类型的Block使用copy方法的效果如下表:

Block的复制操作

根据表得知,Block在堆中copy会造成引用计数增加,这与其他Objective-C对象是一样的。虽然Block在栈中也是以对象的身份存在,但是栈块没有引用计数,因为不需要,我们都知道栈区的内存由编译器自动分配释放。
不管Block存储域在何处,用copy方法复制都不会引起任何问题。在不确定时调用copy方法即可。在ARC有效时,多次调用copy方法完全没有问题:

blk = [[[[blk copy] copy] copy] copy];
// 经过多次复制,变量blk仍然持有Block的强引用,该Block不会被废弃。
1.5 __block变量与__forwarding

在copy操作之后,既然__block变量也被copy到堆上去了, 那么访问该变量是访问栈上的还是堆上的呢?__forwarding 终于要闪亮登场了。通过__forwarding, 无论是在block中还是 block外访问__block变量, 也不管该变量在栈上或堆上, 都能顺利地访问同一个__block变量。

__block与__forwarding

1.6 Block 循环引用

Block 循环引用的情况:
某个类将 block 作为自己的属性变量,然后该类在 block 的方法体里面又使用了该类本身。

self.someBlock = ^(Type var){
    [self dosomething];
};

解决办法:
(1)ARC 下:使用 __weak

__weak typeof(self) weakSelf = self;
self.someBlock = ^(Type var){
   [weakSelf dosomething];
};

(2)MRC 下:使用 __block

__block typeof(self) blockSelf = self;
self.someBlock = ^(Type var){
   [blockSelf dosomething];
};

解决办法:

//1.使用__weak ClassName
    __block XXViewController* weakSelf = self;
    self.blk = ^{
        NSLog(@"In Block : %@",weakSelf);
    };
//2.使用__weak typeof(self)
    __weak typeof(self) weakSelf = self;
    self.blk = ^{
        NSLog(@"In Block : %@",weakSelf);
    };
//3.Reactive Cocoa中的@weakify和@strongify
    @weakify(self);
    self.blk = ^{
        @strongify(self);
        NSLog(@"In Block : %@",self);
    };

二、Block 应用

2.1 Block 应用

1、Block作为变量(Xcode快捷键:inlineBlock)

int (^sum) (int, int); // 定义一个 Block 变量 sum
// 给 Block 变量赋值
// 一般 返回值省略:sum = ^(int a,int b)…
sum = ^int (int a,int b){  
    return a+b;
}; // 赋值语句最后有 分号
int a = sum(10,20); // 调用 Block 变量

2、Block作为属性(Xcode 快捷键:typedefBlock)

// 1. 给  Calculate 类型 sum变量 赋值「下定义」
typedef int (^Calculate)(int, int); // calculate就是类型名
Calculate sum = ^(int a,int b){ 
    return a+b;
};
int a = sum(10,20); // 调用 sum变量

// 2. 作为对象的属性声明,copy 后 block 会转移到堆中和对象一起
@property (nonatomic, copy) Calculate sum;    // 使用   typedef
@property (nonatomic, copy) int (^sum)(int, int); // 不使用 typedef

// 声明,类外
self.sum = ^(int a,int b){
    return a+b;
};
// 调用,类内
int a = self.sum(10,20);

3、作为 OC 中的方法参数

// ---- 无参数传递的 Block ---------------------------
// 实现
- (CGFloat)testTimeConsume:(void(^)())middleBlock {
    // 执行前记录下当前的时间
    CFTimeInterval startTime = CACurrentMediaTime();
    middleBlock();
    // 执行后记录下当前的时间
    CFTimeInterval endTime = CACurrentMediaTime();
    return endTime - startTime;

}

// 调用
[self testTimeConsume:^{
       // 放入 block 中的代码 

}];

// ---- 有参数传递的 Block ---------------------------
// 实现
- (CGFloat)testTimeConsume:(void(^)(NSString * name))middleBlock {
    // 执行前记录下当前的时间
    CFTimeInterval startTime = CACurrentMediaTime();
    NSString *name = @"有参数";
    middleBlock(name);
    // 执行后记录下当前的时间
    CFTimeInterval endTime = CACurrentMediaTime();
    return endTime - startTime;
}

// 调用
[self testTimeConsume:^(NSString *name) {
   // 放入 block 中的代码,可以使用参数 name
   // 参数 name 是实现代码中传入的,在调用时只能使用,不能传值    

}];

4、Block回调
Block回调是关于Block最常用的内容,比如网络下载,我们可以用Block实现下载成功与失败的反馈。block使用简单,逻辑清晰,灵活。

2.2 Block 几种类型演算

    {
        NSLog(@"\n--------------------block调用 基本数据类型---------------------\n");
        int a = 10;
        NSLog(@"block定义前a地址=%p", &a);
        void (^aBlock)() = ^(){
            NSLog(@"block定义内部a地址=%p", &a);
        };
        NSLog(@"block定义后a地址=%p", &a);
        aBlock();
    }
     
    /*
     结果:
     block定义前a地址=0x7fff5bdcea8c
     block定义后a地址=0x7fff5bdcea8c
     block定义内部a地址=0x7fa87150b850
     */
     
    /*
     流程:
     1. block定义前:a在栈区
     2. block定义内部:里面的a是根据外面的a拷贝到堆中的,不是一个a
     3. block定义后:a在栈区
     */
     
    {
        NSLog(@"\n--------------------block调用 __block修饰的基本数据类型---------------------\n");
         
        __block int b = 10;
        NSLog(@"block定义前b地址=%p", &b);
        void (^bBlock)() = ^(){
            b = 20;
            NSLog(@"block定义内部b地址=%p", &b);
        };
        NSLog(@"block定义后b地址=%p", &b);
        NSLog(@"调用block前 b=%d", b);
        bBlock();
        NSLog(@"调用block后 b=%d", b);
    }
     
    /*
     结果:
     block定义前b地址=0x7fff5bdcea50
     block定义后b地址=0x7fa873b016d8
     调用block前 b=10
     block定义内部b地址=0x7fa873b016d8
     调用block后 b=20
     */
     
    /*
     流程:
     1. 声明 b 为 __block (__block 所起到的作用就是只要观察到该变量被 block 所持有,就将“外部变量”在栈中的内存地址放到了堆中。)
     2. block定义前:b在栈中。
     3. block定义内部: 将外面的b拷贝到堆中,并且使外面的b和里面的b是一个。
     4. block定义后:外面的b和里面的b是一个。
     5. block调用前:b的值还未被修改。
     6. block调用后:b的值在block内部被修改。
     */
     
    {
        NSLog(@"\n--------------------block调用 指针---------------------\n");
         
        NSString *c = @"ccc";
        NSLog(@"block定义前:c=%@, c指向的地址=%p, c本身的地址=%p", c, c, &c);
        void (^cBlock)() = ^{
            NSLog(@"block定义内部:c=%@, c指向的地址=%p, c本身的地址=%p", c, c, &c);
        };
        NSLog(@"block定义后:c=%@, c指向的地址=%p, c本身的地址=%p", c, c, &c);
        cBlock();
        NSLog(@"block调用后:c=%@, c指向的地址=%p, c本身的地址=%p", c, c, &c);
    }
     
    /* 输出结果
      block定义前:c=ccc, c指向的地址=0x1068aac68, c本身的地址=0x7ffee93a7ab8
      block定义后:c=ccc, c指向的地址=0x1068aac68, c本身的地址=0x7ffee93a7ab8
      block定义内部:c=ccc, c指向的地址=0x1068aac68, c本身的地址=0x6000002542a0
      block调用后:c=ccc, c指向的地址=0x1068aac68, c本身的地址=0x7ffee93a7ab8
     c指针本身在block定义中和外面不是一个,但是c指向的地址一直保持不变。
     1. block定义前:c指向的地址在堆中, c指针本身的地址在栈中。
     2. block定义内部:c指向的地址在堆中, c指针本身的地址在堆中(c指针本身和外面的不是一个,但是指向的地址和外面指向的地址是一样的)。
     3. block定义后:c不变,c指向的地址在堆中, c指针本身的地址在栈中。
     4. block调用后:c不变,c指向的地址在堆中, c指针本身的地址在栈中。
     */
    {
        NSLog(@"\n--------------------block调用 指针并修改值---------------------\n");
         
        NSMutableString *d = [NSMutableString stringWithFormat:@"ddd"];
        NSLog(@"block定义前:d=%@, d指向的地址=%p, d本身的地址=%p", d, d, &d);
        void (^dBlock)() = ^{
            NSLog(@"block定义内部:d=%@, d指向的地址=%p, d本身的地址=%p", d, d, &d);
            d.string = @"dddddd";
        };
        NSLog(@"block定义后:d=%@, d指向的地址=%p, d本身的地址=%p", d, d, &d);
        dBlock();
        NSLog(@"block调用后:d=%@, d指向的地址=%p, d本身的地址=%p", d, d, &d);
    }
     
    /*输出结果
     block定义前:d=ddd, d指向的地址=0x600000440300, d本身的地址=0x7ffee9b2dab8
     block定义后:d=ddd, d指向的地址=0x600000440300, d本身的地址=0x7ffee9b2dab8
     block定义内部:d=ddd, d指向的地址=0x600000440300, d本身的地址=0x604000253940
     block调用后:d=dddddd, d指向的地址=0x600000440300, d本身的地址=0x7ffee9b2dab8

     d指针本身在block定义中和外面不是一个,但是d指向的地址一直保持不变。
     在block调用后,d指向的堆中存储的值发生了变化。
     */
     
    {
        NSLog(@"\n--------------------block调用 __block修饰的指针---------------------\n");
         
        __block NSMutableString *e = [NSMutableString stringWithFormat:@"eee"];
        NSLog(@"block定义前:e=%@, e指向的地址=%p, e本身的地址=%p", e, e, &e);
        void (^eBlock)() = ^{
            NSLog(@"block定义内部:e=%@, e指向的地址=%p, e本身的地址=%p", e, e, &e);
            e = [NSMutableString stringWithFormat:@"new-eeeeee"];
        };
        NSLog(@"block定义后:e=%@, e指向的地址=%p, e本身的地址=%p", e, e, &e);
        eBlock();
        NSLog(@"block调用后:e=%@, e指向的地址=%p, e本身的地址=%p", e, e, &e);
    }
     
    /*
     从block定义内部使用__block修饰的e指针开始,e指针本身的地址由栈中改变到堆中,即使出了block,也在堆中。
     在block调用后,e在block内部重新指向一个新对象,e指向的堆中的地址发生了变化。
     */
     
    {
        NSLog(@"\n--------------------block调用 retain cycle---------------------\n");
         
        View *v = [[View alloc] init];
        v.tag = 1;
        v.frame = CGRectMake(100, 100, 100, 100);
        [self.view addSubview:v];      //self->view->v
        void (^block)() = ^{
            v.backgroundColor = [UIColor orangeColor]; //定义内部:block->v
        };
        v.block = block;    //v->block
        block();   
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
            //预计3秒后释放v对象。
            [v removeFromSuperview];
        });
    }
     
    /*
     结果:
     不会输出 dealloc.
     */
     
    /*
     流程:
     1. self->view->v
     2. block定义内部:block->v 因为block定义里面调用了v
     3. v->block
      
     结论:
     引起循环引用的是block->v->block,切断其中一个线即可解决循环引用,跟self->view->v这根线无关
     */
     
    {
        NSLog(@"\n--------------------block调用self---------------------\n");
         
        View *v = [[View alloc] init];
        v.tag = 2;
        v.frame = CGRectMake(100, 220, 100, 100);
        [self.view addSubview:v];      //self->view->v
        void (^block)() = ^{
            self.view.backgroundColor = [UIColor redColor]; //定义内部:block->self
            _count ++;   //调用self的实例变量,也会让block强引用self。
             
        };
        v.block = block;    //v->block
        block();
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
            //预计3秒后释放self这个对象。
            AppDelegate *appDelegate = [UIApplication sharedApplication].delegate;
            appDelegate.window.rootViewController = nil;
        });
    }
    /*
     结果:
     不会输出 dealloc.
     */
     
    /*
     流程:
     1. self->view->v
     2. v->block
     3. block->self 因为block定义里面调用了self
      
     结论:
     在block内引用实例变量,该实例变量会被block强引用。
     引起循环引用的是self->view->v->block->self,切断一个线即可解决循环引用。
     */

2.3 Block 存储域

1. 在全局数据区的Block对象

NSGlobalBlock 静态block,释放有两种不同的时机:

  • 1、如果这个block引用了外部变量后是栈block,则在定义此block的函数出栈时,block释放。
  • 2、如果这个blcok引用了外部变量之后是堆block,则其宿主target释放的时候此block才释放。
    {
        NSLog(@"\n--------------------block的存储域 全局块---------------------\n");
         
        void (^blk)(void) = ^{
            NSLog(@"Global Block");
        };
        blk();
        NSLog(@"%@", [blk class]);
    }
    /*
     结果:输出 __NSGlobalBlock__
     */
     
    /*
     结论:
     全局块:这种块不会捕捉任何状态(外部的变量),运行时也无须有状态来参与。块所使用的整个内存区域,在编译期就已经确定。
     全局块一般声明在全局作用域中。但注意有种特殊情况,在函数栈上创建的block,如果没有捕捉外部变量,block的实例还是会被设置在程序的全局数据区,而非栈上。
     */
2.在堆上创建的Block对象

NSMallocBlock 堆区block
堆区是内存的常驻区域,也叫永久存储区,block一般在函数中定义,最多是个栈block。在MRC时代你需要使用Block_copy()方法,才可以将blcok复制到堆中。

复制到堆中有何用处呢?

  • 首先,作为一个对象,把它复制到堆中,想要使用它肯定要有一个指针指向它,而指向它的指针是作为property或静态变量出现的(如果不被引用也就没有了常驻于堆区的意义),而实际开发中多使用poperty引用。
  • 在MRC中,如果一个类的block属性是使用copy修饰的,则不需要手动调用Block_copy将其复制到堆中。如果是用strong修饰的,则必须使用Block_copy()将其复制到堆中,并在释放时调用Block_release()方法将其释放,否则会因野指针导致程序崩溃。
    {
        NSLog(@"\n--------------------block的存储域 堆块---------------------\n");
         
        int i = 1;
        void (^blk)(void) = ^{
            NSLog(@"Malloc Block, %d", i);
        };
        blk();
        NSLog(@"%@", [blk class]);
    }
    /*
     结果:输出 __NSMallocBlock__
     */
     
    /*
     结论:
     堆块:解决块在栈上会被覆写的问题,可以给块对象发送copy消息将它拷贝到堆上。复制到堆上后,块就成了带引用计数的对象了。
      
     在ARC中,以下几种情况栈上的Block会自动复制到堆上:
     - 调用Block的copy方法
     - 将Block作为函数返回值时(MRC时此条无效,需手动调用copy)
     - 将Block赋值给__strong修饰的变量时(MRC时此条无效)
     - 向Cocoa框架含有usingBlock的方法或者GCD的API传递Block参数时
      
     上述代码就是在ARC中,block赋值给__strong修饰的变量,并且捕获了外部变量,block就会自动复制到堆上。
     */
3.在栈上创建的Block对象

NSStackBlock 栈区block

  • 函数只有入栈后才能执行,出栈后就释放了。
  • 栈block一般在函数内部定义,并在函数内部调用;或者在函数外部定义,作为函数的一个参数在函数内部调用。函数出栈时和其他变量或参数一起释放。
    {
        NSLog(@"\n--------------------block的存储域 栈块---------------------\n");
        int i = 1;
        __weak void (^blk)(void) = ^{
            NSLog(@"Stack Block, %d", i);
        };
        blk();
        NSLog(@"%@", [blk class]);
    }
    /*
     结果:输出 __NSStackBlock__
     */
     
    /*
     结论:
     栈块:块所占内存区域分配在栈中,编译器有可能把分配给块的内存覆写掉。
     在ARC中,除了上面四种情况,并且不在global上,block是在栈中。
     */

三、Block 原理

Block 优缺点

优点:

  • 捕获外部变量
  • 降低代码分散程度

缺点:

  • 循环引用引起内存泄露

Block 总结

  • 在block内部使用的是将外部变量的拷贝到堆中的(基本数据类型直接拷贝一份到堆中,对象类型只将在栈中的指针拷贝到堆中并且指针所指向的地址不变)。
  • __block修饰符的作用:是将block中用到的变量,拷贝到堆中,并且外部的变量本身地址也改变到堆中。
  • __block不能解决循环引用,需要在block执行尾部将变量设置成nil
  • __weak可以解决循环引用,block在捕获weakObj时,会对weakObj指向的对象进行弱引用。
  • 使用__weak时,可在block开始用局部__strong变量持有,以免block执行期间对象被释放。
  • 全局块不引用外部变量,所以不用考虑。
  • 堆块引用的外部变量,不是原始的外部变量,是拷贝到堆中的副本。
  • 栈块本身就在栈中,引用外部变量不会拷贝到堆中。
  • __weak 本身是可以避免循环引用的问题的,但是其会导致外部对象释放了之后,block 内部也访问不到这个对象的问题,我们可以通过在 block 内部声明一个 __strong 的变量来指向 weakObj,使外部对象既能在 block 内部保持住,又能避免循环引用的问题。
  • __block 本身无法避免循环引用的问题,但是我们可以通过在 block 内部手动把 blockObj 赋值为 nil 的方式来避免循环引用的问题。另外一点就是 __block 修饰的变量在 block 内外都是唯一的,要注意这个特性可能带来的隐患。
  • block的实现原理是C语言的函数指针。函数指针即函数在内存中的地址,通过这个地址可以达到调用函数的目的。

Q:什么是Block?
A:Block是将函数及其执行上下文封装起来的对象

struct __block_impl{
  void *isa;//Block 是对象的标志
  int Flags;
  int Reserved;
  void *FuncPtr;//函数指针
};

Q:什么是Block调用?
A:Block调用是函数调用

Q:Block 如何截获变量?
A:1.基本数据类型的局部变量截获其值
2.对象类型的局部变量连同所有权修饰符一起截获
3.局部静态变量指针形式截获
4.不截获全局变量、静态全局变量

Q:什么情况使用__block修饰符?
A:一般情况下,对被截获变量进行赋值操作需要添加__block修饰符
赋值 != 使用
赋值:
赋值操作需要使用 __block修饰

__block NSMutableArray *arrM = nil;
    void (^testBlock)(void) = ^{
        arrM = [NSMutableArray array];
    };
    testBlock();

使用:如下代码不需要使用__block,因为是对数组的操作而不是数组的赋值。

NSMutableArray *arrM = [NSMutableArray array];
    void (^testBlock)(void) = ^{
        [arrM addObject:@"addObj"];
    };
    testBlock();
需要修饰符

不需要修饰符

Q:__block做了什么
A:__block修饰变量变成了对象

__block修饰符

Q:Block的Copy操作效果
A:如图

Block的Copy操作效果

Q:栈上Block的销毁
A:如图

栈上Block的销毁

Q:栈上Block的Copy操作
A:如图
Q:栈上Block的Copy,MRC是否会引起内存泄漏
A:会的

i栈上Block的Copy

Q:栈上__block变量的Copy操作
A:如图,修改__block变量值,修改的都是堆上的值

栈上__block变量的Copy操作

Q:__forwarding存在的意义
A:无论在栈还是堆上,__forwarding都可以顺利访问到同一个__block变量

Q:Block外部定义__weak修饰变量可以解决循环引用?
A:Block截获对象连同所有权修饰符一起截获的,如在外部对变量进行__weak修饰,结构体里持有的对象类型也是weak

Q:Block的引用循环,如图代码出现什么问题?

A:MRC下,不会产生循环引用;ARC下回产生循环引用,引起内存泄漏
ARC下的引用循环

ARC下的引用循环

ARC下的引用循环解决方案
解决方案

上述代码:ARC下解决方案
弊端:如果该Block长时间不被引用,该断环处一直存在,循环引用无法解除

解决方案

Question1:__weak修饰对象,当外部对象释放了之后,block 内部也访问不到这个对象,怎么办?

Answer:通过在 block 内部声明一个 __strong 的变量来指向 weakObj,使外部对象既能在 block 内部保持住,又能避免循环引用的问题。

__weak typeof(self) weakSelf = self;
self.block = ^{
      __strong typeof(weakSelf) strongSelf = weakSelf;
      [strongSelf print];
};

我们以 AFNetworking 中 AFNetworkReachabilityManager.m 的一段代码举例:

__weak __typeof(self)weakSelf = self;
AFNetworkReachabilityStatusBlock callback = ^(AFNetworkReachabilityStatus status) {
    __strong __typeof(weakSelf)strongSelf = weakSelf;

    strongSelf.networkReachabilityStatus = status;
    if (strongSelf.networkReachabilityStatusBlock) {
        strongSelf.networkReachabilityStatusBlock(status);
    }
};

Question2:__strong修饰对象,会不会引起循环引用?

Answer:不会!

详解:

__weak修饰的对象被Block引用,不会影响对象的释放,而__strong在Block内部修饰的对象,会保证,在使用这个对象在scope内,这个对象都不会被释放,出了scope,引用计数就会-1。
self是一个指向实例对象的指针,它的生命周期至少是伴随着当前的实例对象的,一旦它和对象之间有循环引用是无法被自动打破的;strongSelf是block内部的一个局部变量,变量的作用域仅限于局部代码,而程序一旦跳出作用域,strongSelf就会被释放,这个临时产生的“循环引用”就会被自动打破,代码的执行事实上也是这样子的。

推荐阅读 https://dhoerl.wordpress.com/2013/04/23/i-finally-figured-out-weakself-and-strongself/

深入篇:iOS-Block本质

最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
  • 序言:七十年代末,一起剥皮案震惊了整个滨河市,随后出现的几起案子,更是在滨河造成了极大的恐慌,老刑警刘岩,带你破解...
    沈念sama阅读 195,980评论 5 462
  • 序言:滨河连续发生了三起死亡事件,死亡现场离奇诡异,居然都是意外死亡,警方通过查阅死者的电脑和手机,发现死者居然都...
    沈念sama阅读 82,422评论 2 373
  • 文/潘晓璐 我一进店门,熙熙楼的掌柜王于贵愁眉苦脸地迎上来,“玉大人,你说我怎么就摊上这事。” “怎么了?”我有些...
    开封第一讲书人阅读 143,130评论 0 325
  • 文/不坏的土叔 我叫张陵,是天一观的道长。 经常有香客问我,道长,这世上最难降的妖魔是什么? 我笑而不...
    开封第一讲书人阅读 52,553评论 1 267
  • 正文 为了忘掉前任,我火速办了婚礼,结果婚礼上,老公的妹妹穿的比我还像新娘。我一直安慰自己,他们只是感情好,可当我...
    茶点故事阅读 61,408评论 5 358
  • 文/花漫 我一把揭开白布。 她就那样静静地躺着,像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上,一...
    开封第一讲书人阅读 46,326评论 1 273
  • 那天,我揣着相机与录音,去河边找鬼。 笑死,一个胖子当着我的面吹牛,可吹牛的内容都是我干的。 我是一名探鬼主播,决...
    沈念sama阅读 36,720评论 3 386
  • 文/苍兰香墨 我猛地睁开眼,长吁一口气:“原来是场噩梦啊……” “哼!你这毒妇竟也来了?” 一声冷哼从身侧响起,我...
    开封第一讲书人阅读 35,373评论 0 254
  • 序言:老挝万荣一对情侣失踪,失踪者是张志新(化名)和其女友刘颖,没想到半个月后,有当地人在树林里发现了一具尸体,经...
    沈念sama阅读 39,678评论 1 294
  • 正文 独居荒郊野岭守林人离奇死亡,尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 34,722评论 2 312
  • 正文 我和宋清朗相恋三年,在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 36,486评论 1 326
  • 序言:一个原本活蹦乱跳的男人离奇死亡,死状恐怖,灵堂内的尸体忽然破棺而出,到底是诈尸还是另有隐情,我是刑警宁泽,带...
    沈念sama阅读 32,335评论 3 313
  • 正文 年R本政府宣布,位于F岛的核电站,受9级特大地震影响,放射性物质发生泄漏。R本人自食恶果不足惜,却给世界环境...
    茶点故事阅读 37,738评论 3 299
  • 文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹,春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,009评论 0 19
  • 文/苍兰香墨 我抬头看了看天上的太阳。三九已至,却和暖如春,着一层夹袄步出监牢的瞬间,已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 30,283评论 1 251
  • 我被黑心中介骗来泰国打工, 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留,地道东北人。 一个月前我还...
    沈念sama阅读 41,692评论 2 342
  • 正文 我出身青楼,却偏偏与公主长得像,于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子,可洞房花烛夜当晚...
    茶点故事阅读 40,893评论 2 335

推荐阅读更多精彩内容