Block的理解和使用

目录

  • Block是什么
  • Block使用
  • Block三种类型
  • Block捕获变量
  • Block循环引用
  • Block总结

Block是什么？

  • block本质上也是一个OC对象，它内部也有个isa指针
  • block是封装了函数调用以及函数调用环境的OC对象
  • block是封装函数及其上下文的OC对象

Block使用

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
}

Block三种类型

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

三种block各自的存储域：

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

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

判断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方法，栈块就会变成堆块。

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

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

image

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

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

Block捕获变量

Q：下述代码输出值为多少？

int age=10;
void (^Block)(void) = ^{
    NSLog(@"age:%d",age);
};
age = 20;
Block();

输出值为 age：10
原因：创建block的时候，已经把age的值存储在里面了。

Q：下列代码输出值分别为多少？

auto int age = 10;
static int num = 25;
void (^Block)(void) = ^{
    NSLog(@"age:%d,num:%d",age,num);
};
age = 20;
num = 11;
Block();

输出结果为：age:10,num:11
愿意：auto变量block访问方式是值传递，static变量block访问方式是指针传递
源码证明：

int age = __cself->age; // bound by copy
int *num = __cself->num; // bound by copy

NSLog((NSString *)&__NSConstantStringImpl__var_folders_2r__m13fp2x2n9dvlr8d68yry500000gn_T_main_d2875b_mi_0, age, (*num));

int age = 10;
static int num = 25;

block = ((void (*)())&__test_block_impl_0((void *)__test_block_func_0, &__test_block_desc_0_DATA, age, &num));

age = 20;
num = 11;

上述代码可查看 static修饰的变量，是根据指针访问的

Q：为什么block对auto和static变量捕获有差异？

auto自动变量可能会销毁的，内存可能会消失，不采用指针访问；static变量一直保存在内存中，指针访问即可

Q：block对全局变量的捕获方式是？

block不需要对全局变量捕获，都是直接采用取值的

Q：为什么局部变量需要捕获？

考虑作用域的问题，需要跨函数访问，就需要捕获

Q：block的变量捕获（capture）

为了保证block内部能够正常访问外部的变量，block有个变量捕获机制

image

Q：block里访问self是否会捕获？

会，self是当调用block函数的参数，参数是局部变量，self指向调用者

Q：block里访问成员变量是否会捕获？

会，成员变量的访问其实是self->xx，先捕获self，再通过self访问里面的成员变量

<article class="_2rhmJa">

Q：Block 如何截获变量？

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

解决Block循环引用

Q：ARC下如何解决block循环引用的问题？

三种方式：__weak、__unsafe_unretained、__block

1.第一种方式：__weak
Person *person = [[Person alloc] init];
//        __weak Person *weakPerson = person;
__weak typeof(person) weakPerson = person;

person.block = ^{
    NSLog(@"age is %d", weakPerson.age);
};
2.第二种方式：__unsafe_unretained
__unsafe_unretained Person *person = [[Person alloc] init];
person.block = ^{
    NSLog(@"age is %d", weakPerson.age);
};
3.第三种方式：__block
__block Person *person = [[Person alloc] init];
person.block = ^{
    NSLog(@"age is %d", person.age);
    person = nil;
};
person.block();
4.三种方法比较
  • __weak：不会产生强引用，指向的对象销毁时，会自动让指针置为nil
  • __unsafe_unretained：不会产生强引用，不安全，指向的对象销毁时，指针存储的地址值不变
  • __block：必须把引用对象置位nil，并且要调用该block
image
image

Q：MRC下如何解决block循环引用的问题？

两种方式：__unsafe_unretained、__block

1.第一种方式：__unsafe_unretained
__unsafe_unretained Person *person = [[Person alloc] init];
person.block = ^{
    NSLog(@"age is %d", weakPerson.age);
};
2.第二种方式：__block
__block Person *person = [[Person alloc] init];
person.block = ^{
    NSLog(@"age is %d", person.age);
};

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语言的函数指针。函数指针即函数在内存中的地址，通过这个地址可以达到调用函数的目的。

参考文章：
https://www.jianshu.com/p/25a7ba546eac
https://www.jianshu.com/p/4e79e9a0dd82

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
【社区内容提示】社区部分内容疑似由AI辅助生成，浏览时请结合常识与多方信息审慎甄别。
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

相关阅读更多精彩内容

友情链接更多精彩内容