block的理解 ios_iOS里关于block的一些理解

最新推荐文章于 2021-05-18 16:33:05 发布

骏绿君

最新推荐文章于 2021-05-18 16:33:05 发布

阅读量146

点赞数

文章标签： block的理解 ios

本文链接：https://blog.csdn.net/weixin_42299775/article/details/111895213

版权

iOS里关于block的一些理解

iOS理论简书待更新文章

介绍

block实际上就是Objective-C语言对于闭包的实现。

block配合上dispatch_queue，可以方便地实现简单的多线程编程和异步编程。

(闭包是一个函数(或指向函数的指针)，再加上该函数执行的外部的上下文变量(有时候也称作自由变量)。)

Block本质是Objective-C的对象，虽然实现了闭包，但并不是函数指针。以下是Block的源码，所以准确的说Block是一个里面存储了指向定义block 时的代码块的函数指针，以及block外部上下文变量信息的结构体。

structBlock_layout{

void*isa;

intflags;

intreserved;

void(*invoke)(void*,...);

structBlock_descriptor*descriptor;

/* Imported variables. */

};

当我们声明一个Block的时候，编译器其实会将Block转换成以上struct结构体。

其中isa指向的是Block具体的类。有如下6种，其中StackBlock、MallocBlock、GlobalBlock是比较常见的。

/* the raw data space for runtime classes for blocks */

/* class+meta used for stack, malloc, and collectable based blocks */

BLOCK_EXPORTvoid*_NSConcreteStackBlock[32];

BLOCK_EXPORTvoid*_NSConcreteMallocBlock[32];

BLOCK_EXPORTvoid*_NSConcreteAutoBlock[32];

BLOCK_EXPORTvoid*_NSConcreteFinalizingBlock[32];

BLOCK_EXPORTvoid*_NSConcreteGlobalBlock[32];

BLOCK_EXPORTvoid*_NSConcreteWeakBlockVariable[32];

分析简单的 Block C++ 源代码

OC代码：

-(void)viewDidLoad{

[superviewDidLoad];

intb=10;

void(^testBlock)(int)=^(inta){

NSLog(@"%d",a+b);

};

b=2;

testBlock(5);

}

C++源码：

struct__block_impl{

void*isa;

intFlags;

intReserved;

void*FuncPtr;

};

staticstruct__ViewController__viewDidLoad_block_desc_0{

size_treserved;

size_tBlock_size;

}

struct__ViewController__viewDidLoad_block_impl_0{

struct__block_impl impl;

struct__ViewController__viewDidLoad_block_desc_0*Desc;

intb;

__ViewController__viewDidLoad_block_impl_0(void*fp,struct__ViewController__viewDidLoad_block_desc_0*desc,int_b,intflags=0):b(_b){

impl.isa=&_NSConcreteStackBlock;

impl.Flags=flags;

impl.FuncPtr=fp;

Desc=desc;

}

};

通过分析上面源码，我们可以得到下面几点结论：结构体中有 isa 指针，证明 Block 也是一个对象。

Block 底层是用结构体来实现的，结构体 _block_impl_0 包含了 __block_impl 结构体和 __block_desc_0 结构体。

__block_impl 结构体中的 FuncPtr 函数指针，指向的就是我们的 Block 的具体实现。真正调用 Block 就是利用这个函数指针去调用的。

__block_desc保存的是预留内存大小和块大小。

为什么能访问外部变量，就是因为将外部变量复制到了结构体中(上面的 int b)，即自动变量会作为成员变量追加到 Block 结构体中。

改为局部静态变量

我们把上面的int b改为static int b，看一下C++源码会变成什么样？

struct__ViewController__viewDidLoad_block_impl_0{

struct__block_impl impl;

struct__ViewController__viewDidLoad_block_desc_0*Desc;

int*b;//主要区别

__ViewController__viewDidLoad_block_impl_0(void*fp,struct__ViewController__viewDidLoad_block_desc_0*desc,int*_b,intflags=0):b(_b){

impl.isa=&_NSConcreteStackBlock;

impl.Flags=flags;

impl.FuncPtr=fp;

Desc=desc;

}

};

我们看到之前是指传递，现在变成了指针传递，因为static的生命周期是整个运行期间，内存在静态数据区，所以只要指针传递就能靠指针来访问。

block的写法

回传值(^名字)(参数列)

Xcode快捷键：inlineBlock

//声明一个square的Block Pointer，其所指向的Block有一个int输入和int输出

typedefint(^square)(int);

//将Block实体指定给square

square=^(inta){returna*a;};

//调用方法，感觉是是不是很像function的用法？

intresult=square(5);

NSLog(@"%d",result);

方法的传入值

当其作为Object-C method的传入值的话，需要把类型写在变量前面，然后加上小括号。比如下面这种写法：

//square参数的类型是int(^)(int)

-(void)objcMethod:(int(^)(int))square;

声明block属性

@property(nonatomic,copy)void(^callBack)(NSDictionary*);

block阵列的使用

{

void(^blocks[3])(void);

for(NSIntegeri=0;i<3;i++){

blocks[i]=^{

NSLog(@"Hello:%i",i);

};

}

blocks[0]();//result:Hello:0

blocks[1]();//result:Hello:1

blocks[2]();//result:Hello:2

}

存取变量Block将使用到的、作用域附近的变量的值建立一份快照拷贝到栈上。

读取和Block pointer同一个Scope的变量值

{

intoutA=8;

int(^myPtr)(int)=^(inta){returnoutA+a;};

//block里面可以读取同一类型的outA的值

intresult=myPtr(3);// result is 11

NSLog(@"result=%d",result);

}

下面这一段代码就不一样了

{

intoutA=8;

int(^myPtr)(int)=^(inta){returnoutA+a;};//block里面可以读取同一类型的outA的值

outA=5;//在调用myPtr之前改变outA的值

intresult=myPtr(3);// result的值仍然是11，并不是8

NSLog(@"result=%d",result);

}

为什么result 的值仍然是11？而不是8呢？事实上，myPtr在其主体中用到的outA这个变量值的时候做了一个copy的动作，把outA的值copy下来，在Block中作为常量使用。所以，之后outA即使换成了新的值，对于myPtr里面copy的值是没有影响的。(类似于深拷贝)

我们也可以看对应的Block的C++实现，我们能看到在_main_block_impl_0这个结构体中我们发现多了一个int类型的成员变量outA，在结构体的构造函数中多了一个参数int _outA，并且用这个int _outA去初始化成员变量outA。

所以在void (*block)(void) = &__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA, a);中传入了自动变量a用来初始化_main_block_impl_0的成员变量outA。那这个时候_main_block_impl_0的成员变量outA就被赋值为8了。

由于上面这一步是值传递，所以当执行outA = 5时，_main_block_impl_0结构体的成员变量outA的值是不会随之改变的，仍然是8。

intoutA=8;

int(*block)(int)=&__main_block_impl_0(__main_block_func_0,&__main_block_desc_0_DATA,outA);

outA=5;

block->FuncPtr)(block);

struct__main_block_impl_0{

struct__block_impl impl;

struct__main_block_desc_0*Desc;

inta;//这是新加入的成员变量

__main_block_impl_0(void*fp,struct__main_block_desc_0*desc,int_outA,intflags=0):outA(_outA){

impl.isa=&_NSConcreteStackBlock;

impl.Flags=flags;

impl.FuncPtr=fp;

Desc=desc;

}

};

需要注意的是，这里copy的值是变量的值，如果它是一个记忆体的位置(地址)，换句话说，就是这个变量是个指针的话，它的值是可以在block里被改变的。(相当于浅拷贝，拷贝的只是一个指针地址，对象地址还是没变的)

{

NSMutableArray*mutableArray=[NSMutableArrayarrayWithObjects:@"one",@"two",@"three",nil];

intresult=^(inta){[mutableArray removeLastObject];returna*a;}(5);

NSLog(@"test array :%@",mutableArray);

}

//原本mutableArray的值是{@"one",@"two",@"three"}，在block里面被更改mutableArray后，就变成{@"one", @"two"}了。

直接存取static类型的变量

因为全局变量或静态变量在内存中的地址是固定的，Block在读取该变量值的时候是直接从其所在内存读出，获取到的是最新值，而不是在定义时copy的常量。

{

staticintoutA=8;

int(^myPtr)(int)=^(inta){returnoutA+a;};

outA=5;

intresult=myPtr(3);

//result的值是8，因为outA是static类型的变量 (该变量在全局数据区分配内存,但作用域还是局部作用域)

NSLog(@"result=%d",result);

}

Block Variable类型的变量

在某个变量前面如果加上修饰字“__block”的话(注意，block前面有两个下划线)，这个变量就称作block variable。基本类型的Block变量等效于全局变量、或静态变量。即将“外部变量”在栈中的内存地址放到了堆中。

那么在block里面就可以任意修改此变量的值，如下代码：

{

__blockintnum=5;

NSLog(@"定义前：%p",&num);

int(^myPtr)(int)=^(inta){

NSLog(@"block内部：%p",&num);

returnnum++;};

int(^myPtr2)(int)=^(inta){

NSLog(@"block内部：%p",&num);

returnnum++;

};

intresult=myPtr(0);//result的值为5，num的值为6

result=myPtr2(0);//result的值为6，num的值为7

NSLog(@"定义后：%p",&num);

NSLog(@"result=%d",result);

}

输出(我们看到num进入block之后内存地址其实改变了，也就是block 内部的变量会被 copy 到堆区)：

2016-09-1216:24:16.622test[20146:972930]定义前：0x7fff5caf0a78

2016-09-1216:24:16.623test[20146:972930]block内部：0x7ff539c0b1a8

2016-09-1216:24:16.623test[20146:972930]定义后：0x7ff539c0b1a8

2016-09-1216:24:16.623test[20146:972930]result=6

本质上加入__block之后，是变成了一个__Block_byref_val_0结构体：

__blockintval=10;

转换成

__Block_byref_val_0 val={

&val,

sizeof(__Block_byref_val_0),

};

struct__Block_byref_val_0{

void*__isa;

__Block_byref_val_0*forwarding;

int__flags;

int__size;

intval;

};

struct__main_block_impl_0{

struct__block_impl impl;

struct__main_block_desc_0*Desc;

__Block_byref_val_0*val;

__main_block_impl_0(void*fp,struct__main_block_desc_0*desc,__Block_byref_val_0*_val,intflags=0):val(_val->__forwrding){

impl.isa=&_NSConcreteStackBlock;

impl.Flags=flags;

impl.FuncPtr=fp;

Desc=desc;

}

};

structvoid__main_block_func_0(struct__main_block_impl_0*__cself){

__Block_byref_val_0*val=__cself->val;

printf("val = %d",val->__forwarding->val);

}

会发现一个局部变量加上__block修饰符后竟然跟block一样变成了一个__Block_byref_val_0结构体类型的自动变量实例。

此时我们在block内部访问val变量则需要通过一个叫__forwarding的成员变量来间接访问val变量。

如果局部变量是对象呢？

通过之前的分析，我们可以将Block修改外部变量成功的情况分为两种：

第一种：Block直接访问全局性的变量，如全局变量、静态全局变量；

第二种：Block间接访问静态局部变量，捕获外部变量并使用指针传递的方式；

Block中不允许修改外部变量的值的问题，变成了不允许修改自动变量的值的问题；但这也并非最终答案，其实最根本的原因还是Block不允许修改栈中指针的内容；

-(void)viewDidLoad{

[superviewDidLoad];

Person*person=[Personnew];

person.name=@"aa";

NSMutableString*name=[@"aa"mutableCopy];

square=^(inta){

person.name=@"aaa";

[name appendString:@""];

person=[Personnew];//Variable is not assignable (missing __block type specifier)

name=[@"aaa"mutableCopy];//Variable is not assignable (missing __block type specifier)

return11+a;

};

intresult=square(10);

NSLog(@"%@",person.name);

NSLog(@"square %d",result);

}

输出：

aaa

我们看如下代码C++的代码，其实变成block结构体之后，block主要做的就是一个指针拷贝，也就是栈中指针的内容不会修改，直接copy了一份指针指向对象：

+(void)logResult{

Person*person1=[[Personalloc]init];

__blockPerson*person2=[[Personalloc]init];

person1.name=@"Mike";

person2.name=@"Sean";

__blockintvi=1;

void(^handler)(NSString*)=^(NSString*name){

person1.name=name;

person2.name=name;

vi=2;

};

handler(@"Lucy");

NSLog(@"%@",person1.name);

NSLog(@"%@",person2.name);

NSLog(@"%i",vi);

}

//对应的C++的结构体

struct__BlockLog__logResult_block_impl_0{

struct__block_impl impl;

struct__BlockLog__logResult_block_desc_0*Desc;

Person*__strong person1;

__Block_byref_person2_0*person2;// by ref

__Block_byref_vi_1*vi;// by ref

__BlockLog__logResult_block_impl_0(void*fp,struct__BlockLog__logResult_block_desc_0*desc,Person*__strong _person1,__Block_byref_person2_0*_person2,__Block_byref_vi_1*_vi,intflags=0):person1(_person1),person2(_person2->__forwarding),vi(_vi->__forwarding){

impl.isa=&_NSConcreteStackBlock;

impl.Flags=flags;

impl.FuncPtr=fp;

Desc=desc;

}

};

为什么对于不同类型的变量，block的处理方式不同呢？变量类型

是否捕获到block内部

访问方式

局部变量auto

是

值传递

局部变量static

是

指针传递

全局变量

否

直接访问这是由变量的生命周期决定的。对于自动变量，当作用域结束时，会被系统自动回收，而block很可能是在超出自动变量作用域的时候去执行，如果之前没有捕获自动变量，那么后面执行的时候，自动变量已经被回收了，得不到正确的值。对于static局部变量，它的生命周期不会因为作用域结束而结束，所以block只需要捕获这个变量的地址，在执行的时候通过这个地址去获取变量的值，这样可以获得变量的最新的值。而对于全局变量，在任何位置都可以直接读取变量的值。

weak–strong dance(避免循环引用)使用方将self或成员变量加入block之前要先将self变为__weak

在多线程环境下(block中的weakSelf有可能被析构的情况下)，需要先将self转为strong指针，避免在运行到某个关键步骤时self对象被析构。

以上两条合起来有个名词叫weak–strong dance

以下是使用weak–strong dance的经典代码

__weak __typeof(self)weakSelf=self和

__strong __typeof(weakSelf)strongSelf=weakSelf

//AFNetworking经典代码

__weak __typeof(self)weakSelf=self;

AFNetworkReachabilityStatusBlockcallback=^(AFNetworkReachabilityStatusstatus){

__strong __typeof(weakSelf)strongSelf=weakSelf;

strongSelf.networkReachabilityStatus=status;

if(strongSelf.networkReachabilityStatusBlock){

strongSelf.networkReachabilityStatusBlock(status);

}

};其中用到了__typeof(self)，这里涉及几个知识点：

a. __typeof、__typeof__、typeof的区别

恩~~他们没有区别，但是这牵扯一段往事，在早期C语言中没有typeof这个关键字，__typeof、__typeof__是在C语言的扩展关键字的时候出现的。

typeof是现代GNU C++的关键字，从Objective-C的根源说，他其实来自于C语言，所以AFNetworking使用了继承自C的关键字。

b.对于老的LLVM编译器上面这句话会编译报错，所以在很早的ARC使用者中流行__typeof(&*self)这种写法，原因如下

大致说法是老LLVM编译器会将__typeof转义为 XXX类名 const __strong的__strong和前面的__weak关键字对指针的修饰又冲突了，所以加上&对指针的修饰。

第四、五、六行，如果不转成strongSelf而使用weakSelf，后面几句话中，有可能在第四句执行之后self的对象可能被析构掉，然后后面的StausBlock没有执行，导致逻辑错误。

最后第五行，使用前对block判空。//以下代码是对__weak __typeof(self)weakSelf = self

//和__strong __typeof(weakSelf)strongSelf = weakSelf的宏定义

#ifndefweakify

#if DEBUG

#if __has_feature(objc_arc)

#defineweakify(object)autoreleasepool{}__weak __typeof__(object)weak##_##object = object;

#else

#defineweakify(object)autoreleasepool{}__block __typeof__(object)block##_##object = object;

#endif

#else

#if __has_feature(objc_arc)

#defineweakify(object)try{}@finally{}{}__weak __typeof__(object)weak##_##object = object;

#else

#defineweakify(object)try{}@finally{}{}__block __typeof__(object)block##_##object = object;

#endif

#ifndefstrongify

#if DEBUG

#if __has_feature(objc_arc)

#definestrongify(object)autoreleasepool{}__typeof__(object)object=weak##_##object;

#else

#definestrongify(object)autoreleasepool{}__typeof__(object)object=block##_##object;

#endif

#else

#if __has_feature(objc_arc)

#definestrongify(object)try{}@finally{}__typeof__(object)object=weak##_##object;

#else

#definestrongify(object)try{}@finally{}__typeof__(object)object=block##_##object;

#endif

//使用方法

@weakify(self);

AFNetworkReachabilityStatusBlockcallback=^(AFNetworkReachabilityStatusstatus){

@strongify(self)

if(!self)return;

self.networkReachabilityStatus=status;

if(self.networkReachabilityStatusBlock){

self.networkReachabilityStatusBlock(status);

}

};

Block的Copy操作

Block的存储域及copy操作

我们上面说过我们用的Block主要有以下三种类型：全局块(_NSConcreteGlobalBlock)：全局块存在于全局内存中, 相当于单例

栈块(_NSConcreteStackBlock)：栈块存在于栈内存中, 超出其作用域则马上被销毁

堆块(_NSConcreteMallocBlock)

这三种block各自的存储域如下图：

一个Block，如何确定存储位置Block不访问外界变量(包括栈中和堆中的变量)

Block 既不在栈又不在堆中，在代码段中，ARC和MRC下都是如此。此时为全局块。

Block访问外界变量

MRC 环境下：访问外界变量的 Block 默认存储栈中。

ARC 环境下：访问外界变量的 Block 默认存储在堆中(实际是放在栈区，然后ARC情况下自动又拷贝到堆区)，自动释放。

全局区

void(^globalBlock)()=^{

};

intmain(intargc,constchar*argv[]){

@autoreleasepool{

void(^stackBlock)()=^{

};

NSLog(@"%@,%@",globalBlock,stackBlock);

}

return0;

}

struct__globalBlock_block_impl_0{

struct__block_impl impl;

struct__globalBlock_block_desc_0*Desc;

__globalBlock_block_impl_0(void*fp,struct__globalBlock_block_desc_0*desc,intflags=0){

impl.isa=&_NSConcreteGlobalBlock;

impl.Flags=flags;

impl.FuncPtr=fp;

Desc=desc;

}

};

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,intflags=0){

impl.isa=&_NSConcreteStackBlock;

impl.Flags=flags;

impl.FuncPtr=fp;

Desc=desc;

}

};

//输出

<0x10a4d41a0>,<0x10a4d41c0>0x10a4d41c0>0x10a4d41a0>

创建的时候stackBlock，但我们马上输出能看到它是全局区的block。

栈区->堆区

intmain(intargc,constchar*argv[]){

@autoreleasepool{

inta=1;

void(^stackBlock)()=^{

NSLog(@"%d",a);

};

NSLog(@"%@",stackBlock);

}

return0;

}

//创建时是栈区block

struct__main_block_impl_0{

struct__block_impl impl;

struct__main_block_desc_0*Desc;

inta;

__main_block_impl_0(void*fp,struct__main_block_desc_0*desc,int_a,intflags=0):a(_a){

impl.isa=&_NSConcreteStackBlock;

impl.Flags=flags;

impl.FuncPtr=fp;

Desc=desc;

}

};

//输出时是堆区block

创建的时候为StackBlock，然后内部引用了非全局的或静态变量，则copy了一份到堆区MallocBlock。

栈区=>全局区

intmain(intargc,constchar*argv[]){

@autoreleasepool{

staticinta=1;

void(^stackBlock)()=^{

NSLog(@"%d",a);

};

NSLog(@"%@",stackBlock);

}

return0;

}

//创建时为栈区

struct__main_block_impl_0{

struct__block_impl impl;

struct__main_block_desc_0*Desc;

int*a;

__main_block_impl_0(void*fp,struct__main_block_desc_0*desc,int*_a,intflags=0):a(_a){

impl.isa=&_NSConcreteStackBlock;

impl.Flags=flags;

impl.FuncPtr=fp;

Desc=desc;

}

};

//输出为全局区

避免循环引用

为什么会发生循环引用呢？因为对象obj在Block被copy到堆上的时候自动retain了一次。因为Block不知道obj什么时候被释放，为了不在Block使用obj前被释放，Block retain了obj一次，在Block被释放的时候，obj被release一次。

retain cycle问题的根源在于Block和obj可能会互相强引用，互相retain对方，这样就导致了retain cycle，最后这个Block和obj就变成了孤岛，谁也释放不了谁。

使用系统的某些block api使用系统的某些block api(如UIView的block版本写动画时)，是否也考虑引用循环问题？

答案来自招聘一个靠谱的iOS第39题，个人测试了一下，感觉是有错误的，我下面代码已注释错误的地方。

系统的某些block api中，UIView的block版本写动画时不需要考虑，但也有一些api 需要考虑：

所谓“引用循环”是指双向的强引用，所以那些“单向的强引用”(block 强引用 self )没有问题，比如这些：

[UIViewanimateWithDuration:duration animations:^{[self.superview layoutIfNeeded];}];

[[NSOperationQueuemainQueue]addOperationWithBlock:^{self.someProperty=xyz;}];

//会发生循环引用

[[NSNotificationCenterdefaultCenter]addObserverForName:@"someNotification"

object:nil

queue:[NSOperationQueuemainQueue]

usingBlock:^(NSNotification*notification){

self.someProperty=xyz;

}];

但如果你使用一些参数中可能含有 ivar 的系统 api ，如 GCD 、NSNotificationCenter就要小心一点：比如GCD 内部如果引用了 self，而且 GCD 的其他参数是 ivar，则要考虑到循环引用，比如以下这些：

//不会发生循环引用

dispatch_group_async(_operationsGroup,_operationsQueue,^

{

[selfdoSomething];

[selfdoSomethingElse];

});

//不会发生循环引用

__weak __typeof__(self)weakSelf=self;

dispatch_group_async(_operationsGroup,_operationsQueue,^

{

__typeof__(self)strongSelf=weakSelf;

[strongSelf doSomething];

[strongSelf doSomethingElse];

});

//会发生循环引用

[[NSNotificationCenterdefaultCenter]addObserverForName:@"someNotification"

object:nil

queue:[NSOperationQueuemainQueue]

usingBlock:^(NSNotification*notification){

self.someProperty=xyz;

}];

//会发生循环引用

_observer=[[NSNotificationCenterdefaultCenter]addObserverForName:@"someNotification"

object:nil

queue:[NSOperationQueuemainQueue]

usingBlock:^(NSNotification*notification){

self.someProperty=xyz;

}];

//不会发生循环引用

__weak __typeof__(self)weakSelf=self;

[[NSNotificationCenterdefaultCenter]addObserverForName:@"someNotification"

object:nil

queue:nil

usingBlock:^(NSNotification*note){

__typeof__(self)strongSelf=weakSelf;

strongSelf.someProperty=xyz;

}];

//不会发生循环引用

__weak __typeof__(self)weakSelf=self;

_observer=[[NSNotificationCenterdefaultCenter]addObserverForName:@"someNotification"

object:nil

queue:nil

usingBlock:^(NSNotification*note){

__typeof__(self)strongSelf=weakSelf;

strongSelf.someProperty=xyz;

}];

参考

骏绿君

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
block的理解 ios_iOS里关于block的一些理解

iOS里关于block的一些理解iOS理论简书待更新文章介绍block实际上就是Objective-C语言对于闭包的实现。block配合上dispatch_queue，可以方便地实现简单的多线程编程和异步编程。(闭包是一个函数(或指向函数的指针)，再加上该函数执行的外部的上下文变量(有时候也称作自由变量)。)Block本质是Objective-C的对象，虽然实现了闭包，但并不是函数指针。以下是...
复制链接

扫一扫