探寻Block的本质（5）—— 对象类型的变量捕获

Block传送门🦋🦋🦋

探寻Block的本质（1）—— 基本认识

探寻Block的本质（2）—— 底层结构

探寻Block的本质（3）—— 基础类型的变量捕获

探寻Block的本质（4）—— Block的类型

探寻Block的本质（6）—— __block的深入分析

首先我们来看这么一段代码案例

*********************CLPerson.h*********************
#import <Foundation/Foundation.h>

@interface CLPerson : NSObject
@property (nonatomic,assign) int age;
@end


*********************CLPerson.m*********************
#import "CLPerson.h"

@implementation CLPerson
-(void)dealloc {
    NSLog(@"%s",__func__);
}
@end

*********************main.m*********************
#import <Foundation/Foundation.h>
#import "CLPerson.h"

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        {//临时作用域开始
            CLPerson *person = [[CLPerson alloc] init];
            person.age = 10;
        }//临时作用域结束
        
        NSLog(@"-----------flag1");
    }
    return 0;
}

通过在打印标记flag1处断点调试可看出，在临时作用域里面的person对象只要出了作用域就会被释放，这一点是很好理解的。

上面的代码加入block，调整如下

*********************CLPerson.h*********************
#import <Foundation/Foundation.h>

@interface CLPerson : NSObject
@property (nonatomic,assign) int age;
@end


*********************CLPerson.m*********************
#import "CLPerson.h"

@implementation CLPerson
-(void)dealloc {
    NSLog(@"%s",__func__);
}
@end

*********************main.m*********************
#import <Foundation/Foundation.h>
#import "CLPerson.h"

typedef void(^CLBlock)(void);//➕➕➕

int main(int argc, const char * argv[]) {
    @autoreleasepool {
	
		CLBlock myBlock;//➕➕➕
        {//临时作用域开始
            CLPerson *person = [[CLPerson alloc] init];
            person.age = 10;

			 myBlock = ^{//➕➕➕
                NSLog(@"---------%d",person.age);
            };
        }//临时作用域结束
        
        NSLog(@"-----------flag1");
    }
    return 0;
}

再次在打印标记flag1处断点调试运行一下 结果告诉我们，出了临时作用域，person对象没有被释放。这里有两个注意点：

• 由于现在是ARC环境，myBlock属于强指针，因此在将block对象赋值给myBlock指针的时候，编译器会自动对block对象执行copy操作，因此赋值完成后，myBlock指向的是一个堆空间上的block对象副本。

顺便，通过终端命令xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m -o main.cpp，拿到编译后的.cpp文件，我们先查看一下当前代码编译底层样式，经整理简化后如下

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  CLPerson *person;

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


static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  CLPerson *person = __cself->person; // bound by copy

                NSLog((NSString *)&__NSConstantStringImpl__var_folders_7__p19yp82j0xd2m_1k8fpr77z40000gn_T_main_2cca58_mi_0,((int (*)(id, SEL))(void *)objc_msgSend)((id)person, sel_registerName("age")));
            }



static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {
            _Block_object_assign((void*)&dst->person, (void*)src->person, 3/*BLOCK_FIELD_IS_OBJECT*/);
}




static void __main_block_dispose_0(struct __main_block_impl_0*src) {
            _Block_object_dispose((void*)src->person, 3/*BLOCK_FIELD_IS_OBJECT*/);
}




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; 
        CLBlock myBlock;

        {
            CLPerson * person = objc_msgSend(objc_msgSend(objc_getClass("CLPerson"), 
                                                          sel_registerName("alloc")
                                                          ), 
                                             sel_registerName("init")
                                             );
            

            objc_msgSend(person, 
                         sel_registerName("setAge:"), 
                         30
                         );


            myBlock = objc_msgSend(&__main_block_impl_0(__main_block_func_0, 
                                                        &__main_block_desc_0_DATA, 
                                                        person, 
                                                        570425344), 
                                   sel_registerName("copy")
                                   );


        }


    }


    return 0;
}

以上是 【ARC环境-->堆上的block-->强指针CLPerson *person 】所对应的运行结果以及底层实现。我们发现于之前捕获一个基本类型的auto变量所不同的是，当block捕捉对象类型的auto变量的时候，__main_block_desc_0结构体里面多了两个彩蛋

• 函数指针copy，也就是__main_block_copy_0()，内部调用了_Block_object_assign()
• 函数指针dispose，也就是__main_block_dispose_0()，内部调用了_Block_object_dispose() 这里还需要注意的是，ARC 下CLPerson *person被认为是强指针，等价于_strong CLPerson *person，而弱指针需要显式地表示为__weak CLPerson *person。通过终端命令xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc -fobjc-arc -fobjc-runtime=ios-9.0.0 main.m -o main.cpp，可以看到block的内捕获到的person指针如下

为了对比，我们再分别看一下下面三种 场景分别是什么情况的：

• ARC环境-->堆上的block-->弱指针__weak CLPerson *person
• ARC环境-->栈上的block-->强指针CLPerson *person
• ARC环境-->栈上的block-->弱指针__weak CLPerson *person

【ARC环境-->堆上的block-->弱指针__weak CLPerson *person】 案例如下

***********************main.m*************************
#import <Foundation/Foundation.h>
#import "CLPerson.h"

typedef void(^CLBlock)(void);


int main(int argc, const char * argv[]) {
    @autoreleasepool {
        CLBlock myBlock;
        
        {//临时作用域开始
            __weak CLPerson * person = [[CLPerson alloc] init];
            person.age = 30;
            
            myBlock = ^{
                NSLog(@"---------%d",person.age);
            } ;
            
        }//临时作用域结束

        NSLog(@"-------------");
        
    }
    
    NSLog(@"------main autoreleasepool end-------");
    
    return 0;
}

block的底层结构如下 运行结果显示堆上的block使用弱指针__weak CLPerson *person，没有影响person所指向对象的生命周期，出了临时作用域的之后就被释放了。

【ARC环境-->栈上的block-->强指针CLPerson *person】

***********************main.m*************************
#import <Foundation/Foundation.h>
#import "CLPerson.h"

typedef void(^CLBlock)(void);


int main(int argc, const char * argv[]) {
    @autoreleasepool {
        CLBlock myBlock;
        
        {//临时作用域开始
            CLPerson * person = [[CLPerson alloc] init];
            person.age = 30;
            
            ^{
                NSLog(@"---------%d",person.age);
            } ;
            
        }//临时作用域结束

        NSLog(@"-------------");
        
    }
    
    NSLog(@"------main autoreleasepool end-------");
    
    return 0;
}

block底层结构如下

运行结果显示栈上的block使用强指针 CLPerson *person，没有影响person所指向对象的生命周期，出了临时作用域的之后就被释放了。

【ARC环境-->栈上的block-->弱指针__weak CLPerson *person】

***********************main.m*************************
#import <Foundation/Foundation.h>
#import "CLPerson.h"

typedef void(^CLBlock)(void);


int main(int argc, const char * argv[]) {
    @autoreleasepool {
        CLBlock myBlock;
        
        {//临时作用域开始
            __weak CLPerson * person = [[CLPerson alloc] init];
            person.age = 30;
            
            ^{
                NSLog(@"---------%d",person.age);
            } ;
            
        }//临时作用域结束

        NSLog(@"-------------");
        
    }
    
    NSLog(@"------main autoreleasepool end-------");
    
    return 0;
}

block底层结构为

运行结果显示栈上的block使用弱指针__weak CLPerson *person，没有影响person所指向对象的生命周期，出了临时作用域的之后就被释放了。

从上面的四种情况的对比看出，只有堆上的block使用强指针CLPerson *person的时候，才会影响该指针所指对象的生命周期，这是怎么一回事呢？

【这个时候就要回到我们上面发现的那两个彩蛋了】也就是__main_block_desc_0中的函数指针copy和dispose。实际上这两个函数指针分别是在block从栈空间拷贝到堆空间的时候，以及堆空间的block被释放的时候使用的。

当block从栈拷贝到堆时，系统会通过block中的函数指针copy调用函数__xxx_block_copy_x

__xxx_block_copy_x(struct __main_block_impl_0*dst, 
				   struct __main_block_impl_0*src
				   );

注意这个函数的两个参数，

• 第一个dst代表拷贝之前栈空间的block，
• 第二个src代表拷贝之后堆空间上的block。

这个函数里面调用的是_Block_object_assign函数

_Block_object_assign((void*)&dst->person, 
					 (void*)src->person, 
					 3/*BLOCK_FIELD_IS_OBJECT*/
					 );

这个函数的作用是把dst（栈block）内部所捕获的那个person对象（指针）的值赋值（assign）给src（堆block）内的person指针。 如果是ARC环境，会根据person的强弱性（也就是之前的修饰词 __weak 和 __strong）来决定src（堆block）是否持有对象。如果person是被__strong修饰，就会通过 [person retain]，使得person所指向的对象的引用计数+1，这样，src（堆block）就持有了（也就是强引用）person所指向的对象。

当堆上的block即将被释放的时候，系统会通过block中的函数指针dispose调用函数__xxx_block_dispose_x

__main_block_dispose_0(struct __main_block_impl_0*src);

很明显其中的参数src就是堆上的block，该函数内部调用了_Block_object_dispose函数

_Block_object_dispose((void*)src->person, 
					  3/*BLOCK_FIELD_IS_OBJECT*/
					  );

ARC下，该函数的作用是，根绝src（堆block）内部的person指针的强弱性（__weak/__strong），决定如何处理person所指向的对象，如果是__strong，说明src持有了person所指向的对象（也就是强引用），因为此时src即将被释放，所以需要放开持有，也即是调用一下[person release]，使得person所指对象的引用计数-1。

为什么上面我都强调了ARC环境下 呢，因为MRC里面是没有__weak和__strong这两个东西的。ARC就是根据我们代码中的__weak/__strong标记，来自动进行一些内存管理相关的处理。相信上面的分析应该能让你有所领悟。

如果回到MRC，其实内存管理本质原则没有变化，无非就是retain和release操作，我个人认为过程会相对ARC来说更简单一些。 首先，内部使用了auto变量（基础类型/对象类型）的block是在栈空间上的，它不会对对象类型的auto变量进行retain操作，也就是不会持有该对象。 当我们对一个栈block调用copy方法进行拷贝操作的时候，会跟ARC一样以相同的方式最终调用_Block_object_assign函数，只不过此时会直接对堆block上 所捕获的对象进行调用retain方法，进行持有，不会进行__weak/__strong的判断，因为MRC里面根本没有这两个小兄弟。 当一个堆上的block即将释放的时候，也会最终调用_Block_object_dispose函数，对该block 所捕获的对象调用release方法，这样堆上的block就放开了对该对象的持有（强引用）。

最后，在通过几张图示，来说明一下【block对于对象类型的auto变量的捕获原理】

以上就是block对于对象类型的auto变量的捕获过程。

Block传送门🦋🦋🦋

探寻Block的本质（1）—— 基本认识

探寻Block的本质（2）—— 底层结构

探寻Block的本质（3）—— 基础类型的变量捕获

探寻Block的本质（4）—— Block的类型

探寻Block的本质（6）—— __block的深入分析