iOS开发——Block内存办理实例剖析

说道block咱们都不生疏,内存办理问题也是开发者最头疼的问题,网上许多讲block的博客,但大都是理论性多点,今日结合一些实例来解说下。

存储域

首要和咱们聊聊block的存储域,依据block在内存中的方位,block被分为三种类型:

  • NSGlobalBlock
  • NSStackBlock
  • NSMallocBlock

从字面意思上咱们也能够看出来
1、NSGlobalBlock是坐落大局区的block,它是设置在程序的数据区域(.data区)中。
2、NSStackBlock是坐落栈区,超出变量效果域,栈上的Block以及 ____block__变量都被毁掉。
3、NSMallocBlock是坐落堆区,在变量效果域完毕时不受影响。

留意:在 ARC 敞开的状况下,将只会有 NSConcreteGlobalBlock 和 NSConcreteMallocBlock 类型的 block。

作为一个开发者,有一个学习的气氛跟一个沟通圈子特别重要,这是一个我的iOS沟通群:413038000,不论你是小白仍是大牛欢迎入驻 ,共享BAT,阿里边试题、面试经历,评论技能, 咱们一同沟通学习生长!

引荐阅览:iOS开发——2020 最新 BAT面试题合集(继续更新中)

说了这么多理论的东西,有些人或许很懵,觉得讲这些有什么用呢,我平常运用block并没有什么问题啊,好了,接下来咱们先来个?感触下:

#import "ViewController.h"
void(^block)(void);
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
NSInteger i = 10;
block = ^{
NSLog(@"%ld", i);
};
}
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
block();
}
@end

声明这样一个block,点击屏幕的时分去调用这个block,然后就会发作以下过错:

iOS开发——Block内存办理实例剖析

野指针过错,清楚明了,这个是生成在栈上的block,由于超出了效果域而被开释,所以再调用的时分报错了,经过打印这个block咱们也能够看到是生成在栈上的:

iOS开发——Block内存办理实例剖析

处理办法

处理办法呢有两种:

  • 一、Objective-C为块常量的内存办理供给了仿制(Block_copy())和开释(Block_release())指令。 运用Block_copy()指令能够将块常量仿制到堆中,这就像完成了一个将块常量引证作为输入参数并回来相同类型块常量的函数。
- (void)viewDidLoad {
[super viewDidLoad];
NSInteger i = 10;
block = Block_copy(^{
NSLog(@"%ld", i);
});
}

为了防止内存走漏,Block_copy()有必要与相应的Block_release()指令到达平衡:

Block_release(block);
  • 二、Foundation结构供给了处理块的copy和release办法,这两个办法具有与Block_copy()和Block_release()函数相同的功用:
- (void)viewDidLoad {
[super viewDidLoad];
NSInteger i = 10;
block = [^{
NSLog(@"%ld", i);
} copy];
}
[block release];

到这儿有人或许会有疑问了,为什么相同的代码我建了一个工程,没有调用copy,也没有报错啊,而且能够正确打印。 那是由于咱们上面的操作都是在MRC下进行的,ARC下编译器现已默许执行了copy操作,所以上面的这个比方就解说了Block超出变量效果域可存在的原因。

接下来或许有人又要问了,block什么时分在大局区,什么时分在栈上,什么时分又在堆上呢?上面的比方是对生成在栈上的Block作了copy操作,假如对别的两种作copy操作,又是什么样的状况呢?

Block的类 装备存储域 仿制效果
_NSConcreteGlobalBlock 程序数据区域 什么也不做
_NSConcreteStackBlock 从栈仿制到堆上
_NSConcreteMallocBlock 引证计数加添加

经过这张表咱们能够明晰看到三种Block copy之后究竟做了什么,接下来咱们就来别离看看这三种类型的Block。

NSGlobalBlock

在记叙大局变量的当地运用block语法时,生成的block为_NSConcreteGlobalBlock类目标

void(^block)(void) = ^ { NSLog(@"Global Block");};
int main() {
}

在代码不截获主动变量时,生成的block也是在大局区:

int(^block)(int count) = ^(int count) {
return count;
};
block(2);

可是经过clang改写的底层代码指向的是栈区:

impl.isa = &_NSConcreteStackBlock

这儿引证巧神的一段话:由于 clang 改写的详细完成办法和 LLVM 不太相同,而且这儿没有敞开 ARC。所以这儿咱们看到 isa 指向的仍是_NSConcreteStackBlock。但在 LLVM 的完成中,敞开 ARC 时,block 应该是 _NSConcreteGlobalBlock 类型

总结下,生成在大局区block有两种状况:

  • 界说大局变量的当地有block语法时
  • block语法的表达式中没有运用应截获的主动变量时

NSStackBlock

装备在大局区的block,从变量效果域外也能够经过指针安全地运用。可是设置在栈上的block,假如其效果域完毕,该block就被毁掉。相同的,由于__block变量也装备在栈上,假如其效果域完毕,则该__block变量也会被毁掉。
上面举得比方其实便是生成在栈上的block:

NSInteger i = 10;
block = ^{
NSLog(@"%ld", i);
};

除了装备在程序数据区域的block(大局Block),其他生成的block为_NSConcreteStackBlock类目标,且设置在栈上,那么装备在堆上的__NSConcreteMallocBlock类何时运用呢?

NSMallocBlock

Blocks供给了将Block和__block变量从栈上仿制到堆上的办法来处理这个问题,这样即便变量效果域完毕,堆上的Block仍然存在。

impl.isa = &_NSConcreteMallocBlock;

这也是为什么Block超出变量效果域还能够存在的原因。

那么什么时分栈上的Block会仿制到堆上呢?

  • 调用Block的copy实例办法时
  • Block作为函数回来值回来时
  • 将Block赋值给附有__strong润饰符id类型的类或Block类型成员变量时
  • 将办法名中含有usingBlock的Cocoa结构办法或GCD的API中传递Block时

上面只对Block进行了阐明,其实在运用__block变量的Block从栈上仿制到堆上时,__block变量也被从栈仿制到堆上并被Block所持有。

接下来咱们再来看一个?:

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

咱们对这个生成在栈上的block执行了copy操作,Block和__block变量均从栈仿制到堆上。
然后在Block效果域之后咱们又运用了与Block无关的变量:

++i;

一个是存在于栈上的变量,一个是仿制到堆上的变量,咱们是怎么做到正确的拜访这个变量值的呢?

经过clang转换下源码来看下:

void(*block)(void);
struct __Block_byref_i_0 {
void *__isa;
__Block_byref_i_0 *__forwarding;
int __flags;
int __size;
NSInteger i;
};
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
__Block_byref_i_0 *i; // by ref
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_i_0 *_i, int flags=0) : i(_i->__forwarding) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
__Block_byref_i_0 *i = __cself->i; // bound by ref
++(i->__forwarding->i);
}
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->i, (void*)src->i, 8/*BLOCK_FIELD_IS_BYREF*/);}
static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->i, 8/*BLOCK_FIELD_IS_BYREF*/);}
static struct __main_block_desc_0 {
size_t reserved;
size_t Block_size;
void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*);
void (*dispose)(struct __main_block_impl_0*);
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0), __main_block_copy_0, __main_block_dispose_0};
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), 10};
block = (void (*)())((id (*)(id, SEL))(void *)objc_msgSend)((id)((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_i_0 *)&i, 570425344)), sel_registerName("copy"));
++(i.__forwarding->i);
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
NSLog((NSString *)&__NSConstantStringImpl__var_folders_47_s4m8c9pj5mg0k9mymsm7rbmw0000gn_T_main_e69554_mi_0, (i.__forwarding->i));
}
return 0;
}
static struct IMAGE_INFO { unsigned version; unsigned flag; } _OBJC_IMAGE_INFO = { 0, 2 };

咱们发现比较于没有__block要害字润饰的变量,源码中添加了一个名为 __Block_byref_i_0 的结构体,用来保存咱们要 capture 而且修正的变量 i。

在__Block_byref_i_0结构体中咱们能够看到成员变量__forwarding,它持有指向该实例本身的指针。那么为什么会有这个成员变量__forwarding呢?这也是正是问题的要害。
咱们能够看到源码中这样一句:

++(i->__forwarding->i);

栈上的__block变量仿制到堆上时,会将成员变量__forwarding的值替换为仿制到堆上的__block变量用结构体实例的地址。所以“不论__block变量装备在栈上仍是堆上,都能够正确的拜访该变量”,这也是成员变量__forwarding存在的理由。

循环引证

循环引证比较简单,形成循环引证的原因无非便是目标和block彼此强引证,形成谁都不能开释,然后形成了内存走漏。根本的一些比方我就不再重复了,网上许多,也比较简单,我就一个问题来评论下,也是开发中有人问过我的一个问题:

  • block里边运用self会形成循环引证吗?

很显然答案不都是,有些状况下是能够直接运用self的,比方调用体系的办法:

[UIView animateWithDuration:0.5 animations:^{
NSLog(@"%@", self);
}];

由于这个block存在于静态办法中,尽管block对self强引证着,可是self却不持有这个静态办法,所以完全能够在block内部运用self。

还有一种状况:
当block不是self的特点时,self并不持有这个block,所以也不存在循环引证

void(^block)(void) = ^() {
NSLog(@"%@", self);
};
block();

只需咱们捉住循环引证的实质,就不难了解这些东西。

最终附上巧神对Block底层源码完成的解说,讲的很透彻,剖析的很好!

期望能够经过上面的一些比方,能够让咱们加深对block的了解,知其然而且知其所以然。

iOS开发——Block内存办理实例剖析