IOS之block,一点小心得

寵の児 提交于 2020-02-06 01:48:21

作为一个iOS开发程序员,没用过block是不可能的。这次我探讨的是block原理,但是有些更深层次的东西,我也不是很清楚,以后随着更加了解block将会慢慢完善。

  第一个问题,什么是block?

  我们都会用block,但是block是什么呢,这是首先要弄清楚的概念。虽然,是什么并不影响我们用它,但是搞清楚原理我们才能更好的去使用它,我觉得作为一个程序员,需要时刻保持对事物原理追究的心态?

  block的是本质是对象。但是你也可以说它是代码块、闭包、内联函数、函数指针...还有很多叫法,也可能这里的叫法都是错误的,或是不准确的,但是我个人觉得从功能上讲,可以这么理解。不过为了对oc的尊敬,还是叫它block吧,block就是block。在其他语言中也有类似block的语法,像javascript的闭包,函数里面的函数,java中的代码块,c中的函数指针等。就好像,事先放一段代码在这里,然后需要的时候回过头来调用。我们知道,代码执行是按顺序调用的,也就是我们常说的面向过程。但是block可以反向调用。只不过block可以写在函数里面,也可以说它是函数中的函数,它是比较特殊的函数。我们看下面的一个例子。

 
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        int i = 0;
        void (^block)() = ^(){
            NSLog(@"%i", i);
        };
        block();
    }
    return 0;
}
 

  block先放在i=0;的后面,但是它没有立即执行,在使用block();后它才执行,这就是block。至于block本质,到后面会讲到。

  第二个问题,为什么要用block?

  虽然知道了什么是block,但是我们为什么要用呢?什么情况下用呢?这个问题其实也很重要,要掌握他的应用场景,我们才能用好它。

  最常用的情况,网络请求。当调用网络的的API请求服务器的数据的时候,我们不知道什么时候才会完成,这个时候程序也不可能停下来等待请求完成再继续运行,这样肯定是不行的。在请求成功的时候,去执行一些操作,这个时候我们需要做到一件事,就是执行事先已经准备好的一段代码。这种情况不正好与block吻合了吗,block不就是来干这件事的吗?有人会说,用代理也可以做到啊,没错,代理也可以实现这种场景需要的操作。但是block它的好处在于简洁,代理以后再谈。

  再举一个例子,你写了一个页面,页面上有按钮可以点击,但是点击事件是用户点了之后才触法的,而你的响应事件想放在控制器中处理(遵循一下MVC设计模式)。这个时候,也可以用block。

  总的来说,当你的程序中需要用到回调的时候,用block会让你思路清晰,代码简洁。

  第三个问题,如何用block?

  1.block的定义:void(^a)()=^(){};

 
=前面:
    void:返回值类型;
    ()():语法结构,第一个括号里面是block名字,第二个括号里面是参数列表,和c或java中参数列表写法一样;例如:int i,char c...
    ^:脱字符,block标识
    a:block名称,就像函数名,对象实例化名称,说白了就是一个名字;
=号后面:
    ^是block标识;
    ()参数列表,当没有参数时,可以省略,但是“=”前面的()参数列表不能省略;
    {}要执行的代码放在这里面,最后加“;”
 

  最后调用,a();跟方法的调用何其相似。但是它和方法有一个非常明显的区别,方法可以在当前类中(或是在main函数中)都可以调用,但是block不同,它出了它所在的作用域就不能被调用了。就像变量一样,说到这里,你是不是想到了奖block设为全局。没错,下面我们使用一下全局block。

  2.全局block

 
void(^globeBlock)(int, int);
void max(int, int);
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        globeBlock = ^(int i, int j){
            printf("%d\n", i>j?i:j);
        };
        max(1, 2);
    }
    return 0;
}
void max(int i, int j){
    globeBlock(i,j);
}
 

  上面的代码中,我们可以看到,声明了一个全局的block,在main函数中实现,在max方法中调用。这样就可以让block在全局中都能调用,但是一定要实现block,否则会报错。全局block原理和变量一样,这里不多说了。有全局block,那么有没有静态block呢(别打我,我也是推测),试了一下,好像没有,也可能我写法不对。

  3.将block用作为对象的属性。

  创建一个类Block,.h文件中:

typedef void (^block)();
@interface Block : NSObject
@property (nonatomic, assign) block myBlock;
- (void)start;

  .m文件中

- (void)start{
    if (self.myBlock) {
        self.myBlock();
    }
}

  在main函数中:

__block int i = 0;
Block *block = [Block new];
block.myBlock = ^{
    i++;
};
[block start];

  这种写法是比较常用的,但是也会造成一些问题,例如:retain cycle,这个放在后面说。

  4.将block作为变量传递。

  还是用上面的类举例。.h文件中:

- (void)show:(void (^)(NSInteger index))paramBlock;

  .m文件中

- (void)show:(void (^)(NSInteger index))paramBlock{
    paramBlock(1);
}

  main函数中调用:

[block show:^(NSInteger index) {
  NSLog(@"%li", index);
}];

  这样就将block当作变量传递了,一些网络请求库里面会经常用这种方式。

  上面讲到的有关block的概念都是一些比较基础的东西,下面会讲block更深层的理论。

  1.retain cycle,循环引用一直是一个老生常谈的问题,我相信99.9的oc程序员都遇到过,并都能很好的解决,所以我这里也不赘述,简单说一下。

  retain cycle在block中是怎么产生的。自从iOS引进了ARC之后,内存管理变得方便,但同时有些情况让人头疼。当对象A持有对象B的时候,A释放,B会随着A的释放而释放。那么问题来了,如果B也持有对象A,那么A会随着B的释放而释放。很好,现在A、B都在等对方释放,互相伤害啊,结果大家都不释放,这样便造成了循环引用。用weak关键字修饰,或是用其他的方法,都可以解决,这里不多说,没多大意思了。

  2.不会形成retain cycle的block。像UIKit中UIView的block动画它不会形成retain cycle,还有网络库AF中的回调也不会形成retain cycle。没有形成retain cycle说明没有互相强引用,UIView调用的是类方法,当前控制器不可能强引用一个类,所以并没有造成retain cycle;至于AF里面怎么做到的,说实话我也不是很清楚,哈哈,还要研究一下。既然如此,那我们来写写不会造成循环引用的block。

  2.1block里面没有引用当前控制器

  视图控制器是TestViewController,有一个属性testView,类TestView代码如下:

 
.h
@interface TestView : UIView
{
    NSString *str;
}
@property (nonatomic, copy) void(^block)();
@end

.m
#import "TestView.h"

@implementation TestView
- (void)dealloc{
    NSLog(@"TestView 被释放");
}
- (instancetype)initWithFrame:(CGRect)frame{
    if (self = [super initWithFrame:frame]) {
        self.backgroundColor = [UIColor blackColor];
        UITapGestureRecognizer *tap = [[UITapGestureRecognizer alloc] initWithTarget:self action:@selector(click)];
        [self addGestureRecognizer:tap];
    }
    return self;
}

- (void)click{
    if (self.block) {
        self.block();
    }
}

@end
 

  TestViewController代码如下:

 
- (void)dealloc{
    NSLog(@"TestViewController 被释放");
}

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view.
    self.view.backgroundColor = [UIColor whiteColor];
    self.testView = [[TestView alloc] initWithFrame:CGRectMake(100, 200, 50, 50)];
    self.testView.block = ^{
        NSLog(@"没有引用self");
    };
    [self.view addSubview:self.testView];
    
}
 

  在block中,没有引用self,所以当前控制器didDisAppear之后就销毁了。

2017-07-07 11:16:33.556 noRetainBlock[1319:39876] TestViewController 被释放
2017-07-07 11:16:33.557 noRetainBlock[1319:39876] TestView 被释放

  会造成循环引用的情况:

  然后TestViewController和TestView都没有被释放,成功造成retain cycle。用weak修饰一下self就可以了,这里不说了。

  2.2类方法调用,block作为变量,TestView代码如下:

 
.h
@interface TestView : UIView
@property (nonatomic, copy) void(^block)();
+ (void)show:(void(^)())myBlock;
@end

.m
#import "TestView.h"

@implementation TestView
- (void)dealloc{
    NSLog(@"TestView 被释放");
}
- (instancetype)initWithFrame:(CGRect)frame{
    if (self = [super initWithFrame:frame]) {
        self.backgroundColor = [UIColor blackColor];
        UITapGestureRecognizer *tap = [[UITapGestureRecognizer alloc] initWithTarget:self action:@selector(click)];
        [self addGestureRecognizer:tap];
    }
    return self;
}
- (void)click{
    if (self.block) {
        self.block();
    }
}
+ (void)show:(void (^)())myBlock{
    myBlock();
}
@end
 

  控制器中调用:

 
- (void)dealloc{
    NSLog(@"TestViewController 被释放");
}

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view.
    self.view.backgroundColor = [UIColor whiteColor];
    [TestView show:^{
        [self show];
    }];
}
- (void)show{
    NSLog(@"show");
}
 

  最后,控制器消失之后被释放

2017-07-07 11:40:15.482 noRetainBlock[1608:52010] show
2017-07-07 11:40:17.784 noRetainBlock[1608:52010] TestViewController 被释放

  不要问我,为什么testView没有被释放,因为根本就没有创建这个对象,哈哈,被show了吧。还有一种写法我试过了,也会造成retain cycle,将testView不设为控制器的属性,这样不会有警告,但是最终还是会造成循环引用,因为析构函数没有被调用。

  以上两种均可以避开循环引用,不过貌似第一种没啥用。因为不在里面操作self的一些方法貌似这个block没啥意义,说到底也只写了一种。至于还有没有其他的写法,我还没有研究。以后要是发现了会补上的。接下来,我们将看看block到底是什么东西。

  在看block源码之前,我们先回到下面这段代码,仔细看看会发现,i被__block修饰了。

__block int i = 0;
Block *block = [Block new];
block.myBlock = ^{
    i++;
};
[block start];

  那么不用__block修饰会是什么样子呢?答案是:如果在block中修改局部变量i的值,那么编译器会报错,根本不能通过编译,不过你要打印或是给其他变量赋值还是可以的。既然这样,我们来看看上述写法和下面写法的两种源码,在终端cd到main函数所在文件夹,使用命令 clang -rewrite-objc main.m会得到main.cpp的文件。可以查看源码。

  第一种,不用__block修饰,打印变量i:

 
int i = 0;
void(^block)() = ^{
    NSLog(@"%i", i);
};
block();

cpp文件中,末尾,因为大概有95000行代码,只取最后部分代码
struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int i;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _i, int flags=0) : i(_i) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  int i = __cself->i; // bound by copy
    NSLog((NSString *)&__NSConstantStringImpl__var_folders_s1_pqp17thd18bdxjswsty3xkmh0000gn_T_main_e26a0c_mi_0, i);
   }
static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};
int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
        int i = 0;
        void(*block)() = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, i));
        ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
    }
    return 0;
}
 

  源码中__main_block_impl_0和__main_block_desc_0中的信息告诉我们block的本质了,它有一个isa指针,可以将block看成一个对象,但是不能说它就是一个对象。在上述源码中可以看到,block中将变量i拷贝了一份,也就是说,block外面的i和里面的i是两个变量。就好像实参和行参的关系。行参将实参拷贝了一份,放在内存中。oc做了优化,不能直接改变局部变量i的值。但是用__block修饰变量i之后就可以改变了。这又是为啥呢,看下面的源码(只看main中的):

 
__block int i = 0;
void(^block)() = ^{
    i++;
    NSLog(@"%i", i);
};
block();

int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
        __attribute__((__blocks__(byref))) __Block_byref_i_0 i = {(void*)0,(__Block_byref_i_0 *)&i, 0, sizeof(__Block_byref_i_0), 0};
        void(*block)() = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_i_0 *)&i, 570425344));
        ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
    }
    return 0;
}
 

  我们可以看到__attribute__((__blocks__(byref))) __Block_byref_i_0 i = {(void*)0,(__Block_byref_i_0 *)&i, 0, sizeof(__Block_byref_i_0), 0};被__block修饰过的变量i变成这样了,然后在block中的i是(__Block_byref_i_0 *)&i,一个地址。原来,用__block修饰过的i传入block里面时,是地址,所以可以改变i的值。

  其实还有一个变量的值是可以在block中修改的,全局变量,静态变量。但是要注意,在改变变量的值的时候要注意循环引用的问题。

  总结:block是一个很有趣的东西,掌握它,弄清楚原理,才能更好的使用它。

易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!