iOS Block（二）----本质篇

qq_43364806

于 2020-02-12 12:32:39 发布

阅读量110

点赞数

本文链接：https://blog.csdn.net/qq_43364806/article/details/104274216

版权

大纲

Block的本质
Block变量捕获
Block类型

Block的本质

Block是“带有自动变量值的匿名函数”，但Block究竟是什么呢？
本质就是一个OC对象，内部有isa指针，Block是封装了函数调用以及函数调用环境的OC对象。

先来简单写一个block

int main () {
	void(^blk)(void) = ^{
		printf("Block\n");
	};
	blk();
	return 0 ;
}

打开终端输入命令
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m

这里是使用clang将OC代码转为C/C++

看到这么多代码，你会头大的，先滑到下面，边说你边看？

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

struct __block_impl {
  void *isa;
  int Flags;
  int Reserved;
  void *FuncPtr;
};

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  printf("Block\n");
}

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 () {
 void(*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
  ((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
  return 0;
}

我们需要明白这里一共是有三个结构体的，给大家一张思维导图在这里插入图片描述

首先是一个大的结构体struct _main_block_impl_0，里面有struct _block_impl和static struct __main_block_desc_0两个结构体，当然了，里面还有一个同名的构造函数，构造函数中对一些变量进行了赋值最终会返回一个结构体。

结构我们已然清楚，让我们来看看究竟是怎样实现的，我们把main函数中的代码简化一下

struct __main_block_impl_0 temp = __main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA)

struct __main_block_impl_0 *blk = &tmp ;

这样就容易理解了，该源代码将__main_block_impl_0结构体类型的自动变量，即栈上生成的 __main_block_impl_0结构体实例的指针，赋值给__main_block_impl_0结构体指针类型的变量blk。这部分对应的源代码为

 void(*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));

下面来看看__main_block_impl_0结构体实例构造参数

__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA)

__main_block_func_0（就是我们写在block中的代码）

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  printf("Block\n");
}

&__main_block_desc_0_DATA（就是__main_block_impl_0的占用空间大小）

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)
};

那怎样初始化的呢？还记得这个同名构造函数吗？

//flags可以不用传
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }

__main_block_func_0对应着void *fp
&__main_block_desc_0_DATA对应着struct __main_block_desc_0 *desc

虽然大家很想知道&_NSConcreteStackBlock是什么，但我们还是先说完其他部分,FuncPtr则存储着__main_block_func_0函数的地址，Desc指向__main_block_desc_0结构体对象，其中存储__main_block_impl_0结构体所占用的内存。

这些关系，结构都弄明白后，我们来看看
**block（）**是怎样做的

((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);

通过上述代码可以发现是通过block找到FunPtr直接调用，通过上面分析我们知道block指向的是__main_block_impl_0类型结构体，但是我们发现__main_block_impl_0结构体中并不直接就可以找到FunPtr，而FunPtr是存储在__block_impl中的，为什么block可以直接调用__block_impl中的FunPtr呢？

重新查看上述源代码可以发现，(__block_impl *)block将block强制转化为__block_impl类型的，因为__block_impl是__main_block_impl_0结构体的第一个成员，相当于将__block_impl结构体的成员直接拿出来放在__main_block_impl_0中，那么也就说明__block_impl的内存地址就是__main_block_impl_0结构体的内存地址开头。所以可以转化成功，并找到FunPtr成员。

总结
在这里插入图片描述

Block变量捕获

auto变量：介绍篇中我们已经了解过block对auto变量的捕获
static变量：static 修饰的变量为指针传递，同样会被block捕获。

我们来看看他们的区别

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        auto int a = 10;
        static int b = 11;
        void(^block)(void) = ^{
            NSLog(@"hello, a = %d, b = %d", a,b);
        };
        a = 1;
        b = 2;
        block();
    }
    return 0;
}
输出:a = 10, b = 2
block中a的值没有被改变而b的值随外部变化而变化。

生成C++代码看看
在这里插入图片描述

我们可以很清楚的看到a传入的是值，而b传入的是指针

为什么两种变量会有这种差异呢，因为自动变量可能会销毁，block在执行的时候有可能自动变量已经被销毁了，那么此时如果再去访问被销毁的地址肯定会发生坏内存访问，因此对于自动变量一定是值传递而不可能是指针传递了。而静态变量不会被销毁，所以完全可以传递地址。而因为传递的是值得地址，所以在block调用之前修改地址中保存的值，block中的地址是不会变得。所以值会随之改变

那如果是全局变量呢？

int a = 10;
static int b = 11;
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        void(^block)(void) = ^{
            NSLog(@"hello, a = %d, b = %d", a,b);
        };
        a = 1;
        b = 2;
        block();
    }
    return 0;
}
输出： a = 1, b = 2

同样地，看看C++
在这里插入图片描述

通过上述代码可以发现，__main_block_imp_0并没有添加任何变量，因此block不需要捕获全局变量，因为全局变量无论在哪里都可以访问。

局部变量因为跨函数访问所以需要捕获，全局变量在哪里都可以访问，所以不用捕获。

在这里插入图片描述

总结：局部变量都会被block捕获，自动变量是值捕获，静态变量为地址捕获。全局变量则不会被block捕获

如果捕获的对象类型呢？

#import "Person.h"
@implementation Person
- (void)test
{
    void(^block)(void) = ^{
        NSLog(@"%@",self);
    };
    block();
}
- (instancetype)initWithName:(NSString *)name
{
    if (self = [super init]) {
        self.name = name;
    }
    return self;
}
+ (void) test2
{
    NSLog(@"类方法test2");
}
@end

同样地，转化为C++
在这里插入图片描述
上图中可以发现，self同样被
block捕获，接着我们找到test方法可以发现，test方法默认传递了两个参数self和_cmd。而类方法test2也同样默认传递了类对象self和方法选择器_cmd。

接着我们来看一下如果在block中使用成员变量或者调用实例的属性会有什么不同的结果。

- (void)test
{
    void(^block)(void) = ^{
        NSLog(@"%@",self.name);
        NSLog(@"%@",_name);
    };
    block();
}

在这里插入图片描述
上图中可以发现，即使block中使用的是实例对象的属性，block中捕获的仍然是实例对象，并通过实例对象通过不同的方式去获取使用到的属性

Block类型

block类型有三种

_NSConcreteGlobalBlock
_NSConcreteStackBlock
_NSConcreteMallocBlock

看看block在什么情况下其类型会各不同

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // 1. 内部没有调用外部变量的block
        void (^block1)(void) = ^{
            NSLog(@"Hello");
        };
        // 2. 内部调用外部变量的block
        int a = 10;
        void (^block2)(void) = ^{
            NSLog(@"Hello - %d",a);
        };
       // 3. 直接调用的block的class
        NSLog(@"%@ %@ %@", [block1 class], [block2 class], [^{
            NSLog(@"%d",a);
        } class]);
    }
    return 0;
}

输出：

Block[19652:2083756] _NSConcreteGlobalBlock、_NSConcreteStackBlock、_NSConcreteMallocBlock

但是我们上面提到过，上述代码转化为c++代码查看源码时却发现block的类型与打印出来的类型不一样，c++源码中三个block的isa指针全部都指向_NSConcreteStackBlock类型地址。
我们可以猜测runtime运行时过程中也许对类型进行了转变。最终类型当然以runtime运行时类型也就是我们打印出的类型为准。

block在内存中的存储
在这里插入图片描述上图中可以发现，根据block的类型不同，block存放在不同的区域中。
数据段中的__NSGlobalBlock__直到程序结束才会被回收，不过我们很少使用到__NSGlobalBlock__类型的block，因为这样使用block并没有什么意义。

__NSStackBlock__类型的block存放在栈中，我们知道栈中的内存由系统自动分配和释放，作用域执行完毕之后就会被立即释放，而在相同的作用域中定义block并且调用block似乎也多此一举。

__NSMallocBlock__是在平时编码过程中最常使用到的。存放在堆中需要我们自己进行内存管理。

在这里插入图片描述

接着我们使用代码验证上述问题，首先关闭ARC回到MRC环境下，因为ARC会帮助我们做很多事情，可能会影响我们的观察。但在最新版本下，设置MRC，运行后会报错，原因在于main.m中
main.m
把return这句话拿进去就可以了。

// MRC环境！！！
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // Global：没有访问auto变量：__NSGlobalBlock__
        void (^block1)(void) = ^{
            NSLog(@"block1---------");
        };   
        // Stack：访问了auto变量： __NSStackBlock__
        int a = 10;
        void (^block2)(void) = ^{
            NSLog(@"block2---------%d", a);
        };
        NSLog(@"%@ %@", [block1 class], [block2 class]);
        // __NSStackBlock__调用copy ： __NSMallocBlock__
        NSLog(@"%@", [[block2 copy] class]);
    }
    return 0;
}

输出：

Block[19652:2083756] __NSGlobalBlock __NSStackBlock __NSMallocBlock

通过打印的内容可以发现正如上图中所示。
没有访问auto变量的block是__NSGlobalBlock__类型的，存放在数据段中。
访问了auto变量的block是__NSStackBlock__类型的，存放在栈中。
__NSStackBlock__类型的block调用copy成为__NSMallocBlock__类型并被复制存放在堆中。

上面提到过__NSGlobalBlock__类型的我们很少使用到，因为如果不需要访问外界的变量，直接通过函数实现就可以了，不需要使用block。

但是__NSStackBlock__访问了aotu变量，并且是存放在栈中的，上面提到过，栈中的代码在作用域结束之后内存就会被销毁，那么我们很有可能block内存销毁之后才去调用他，那样就会发生问题，通过下面代码可以证实这个问题。

void (^block)(void);
void test()
{
    // __NSStackBlock__
    int a = 10;
    block = ^{
        NSLog(@"block---------%d", a);
    };
}
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        test();
        block();
    }
    return 0;
}

输出：

Block[19711:2090914] block----------492800872

可以发现a的值变为了不可控的一个数字。为什么会发生这种情况呢？因为上述代码中创建的block是__NSStackBlock__类型的，因此block是存储在栈中的，那么当test函数执行完毕之后，栈内存中block所占用的内存已经被系统回收，因此就有可能出现乱得数据。查看其c++代码可以更清楚的理解

在这里插入图片描述

为了避免这种情况发生，可以通过copy将NSStackBlock类型的block转化为NSMallocBlock类型的block，将block存储在堆中，以下是修改后的代码

void (^block)(void);
void test()
{
    // __NSStackBlock__ 调用copy 转化为__NSMallocBlock__
    int age = 10;
    block = [^{
        NSLog(@"block---------%d", age);
    } copy];
    [block release];
}

输出：

Block[19730:2094118] block---------10

那么其他类型的block调用copy会改变block类型吗？下面表格已经展示的很清晰了。
在这里插入图片描述
所以在平时开发过程中MRC环境下经常需要使用copy来保存block，将栈上的block拷贝到堆中，即使栈上的block被销毁，堆上的block也不会被销毁，需要我们自己调用release操作来销毁。而在ARC环境下回系统会自动copy，是block不会被销毁。

什么情况下ARC会自动将block进行一次copy操作？

block作为函数返回值时
将block赋值给__strong指针时
block作为Cocoa API中方法名含有usingBlock的方法参数时
block作为GCD API的方法参数时
例如：GDC的一次性函数或延迟执行的函数，执行完block操作之后系统才会对block进行release操作。

block声明写法

MRC下block属性的建议写法
@property (copy, nonatomic) void (^block)(void);
ARC下block属性的建议写法
@property (strong, nonatomic) void (^block)(void);
@property (strong, nonatomic) void (^block)(void);

最后

这里放上我喜欢的大神写的文章iOS底层原理总结 - 探寻block的本质（一）

qq_43364806

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
iOS Block（二）----本质篇

大纲Block的本质Block变量捕获Block类型Block的本质Block是“带有自动变量值的匿名函数”，但Block究竟是什么呢？本质就是一个OC对象，内部有isa指针，Block是封装了函数调用以及函数调用环境的OC对象。先来简单写一个blockint main () { void(^blk)(void) = ^{ printf("Block\n"); }; ...
复制链接

扫一扫