_我们先通过一个小场景,开始今天的主题.

在block内部修改auto变量

一:__block的本质

我们把使用__block修饰的age转换为C++代码,对比一下:

OC代码和底层C++代码对比

__block修饰的age的底层代码

简化后的声明代码和结构体对应图

ok,现在我们来梳理一下使用__block修饰的age变量和block的关系,为此,我截了一张 OC 代码和转换后的 C++ 代码的对比图,这样能更清晰的展示他们之间的关系:

age 对象和blcok的关系

block代码块对比

思考一:为什么苹果要设计forwarding这种多此一举的方式呢?
因为当block从栈上拷贝到堆上后,__block变量也会拷贝到堆上.这时就有两份__block变量,一份栈上的,一份堆上的.而栈上的__block变量随时可能销毁,访问时可能出现野指针情况,为了保证始终访问同一份有效且安全的数据,需要把栈上__block的forwarding指针指向堆上__block地址.这样就能保证即使访问栈上的__block变量也能获取到堆上的变量值,如图:

思考二:如果我们修改的外部变量是对象类型,它的底层是怎样的呢?

对象类型和基本数据类型对比

思考三:如图所示,我们在block内部给外部没有使用__block修饰的array类型的auto变量添加元素,会编译成功吗?

思考四:通过上述分析,我们知道age结构体中会有一个成员存储auto变量的值,所以现在就有两个age.一个是age 结构体,另一个是存储变量值得age成员,那我们如果打印age的地址,会是哪个age的地址呢?

真假age

typedef void(^MYBlock)(void);
//impl结构体
struct __block_impl {
    void *isa;
    int Flags;
    int Reserved;
    void *FuncPtr;
};

//age结构体
struct __Block_byref_age_0 {
    void *__isa;
    struct __Block_byref_age_0 *__forwarding;
    int __flags;
    int __size;
    int age;
};
//Desc结构体
struct __main_block_desc_0 {
    size_t reserved;
    size_t Block_size;
    void (*copy)(void);
    void (*dispose)(void);
};
//block结构体
struct __main_block_impl_0 {
    struct __block_impl impl;
    struct __main_block_desc_0* Desc;
    struct __Block_byref_age_0 *age; // by ref
};

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        //声明age
        __block int age = 10;
    
        //声明block
        MYBlock block = ^{
            age = 20;
            NSLog(@"%p",&age);
        };  
        struct __main_block_impl_0 *blockImpl = (__bridge struct __main_block_impl_0 *)block;
        //调用block
        block();
    }
    return 0;
}

这样我们就实现了把Block类型转换为struct __main_block_impl_0结构体,方便我们查看block结构体中成员变量的地址.

age结构体中的成员

• 验证方法一:
  我们在变量视图中看到age结构体的地址是0x100405980,而我们知道,结构体的地址也是结构体第一个成员的地址,由此我们可以手动计算出结构体中age成员的地址:

//age结构体
struct __Block_byref_age_0 {//0x100405980 age结构体地址
  void *__isa;// 占8字节 0x100405980 第一个成员的地址和age的地址相同
__Block_byref_age_0 *__forwarding;// 占8字节 isa的地址:0x100405980 + isa所占用的8字节 =  0x100405988
 int __flags;// 占4字节  __forwarding 的地址:0x100405988 + __forwarding 所占用的8字节 = 0x100405990
 int __size;// 占4字节   __flags地址:0x100405990 + __flags 所占用的4字节 = 0x100405994
 int age; // 占4字节  __size 地址:0x100405994 + __size 所占用的4字节 = 0x100405998
};

可以看到,我们计算处理的地址0x100405998和打印出来的地址0x100405998是相同的,验证了我们刚才得出的结论.

• 验证方法二:通过命令行打印地址:
  
  
  我们通过LLDB命令p/x &(blockImpl->age->age)打印出的age地址和NSLog输出的地址是相同的,再一次验证了我们刚才的结论.这张截图中的地址和上一张图中的地址不一样,是因为这张图是重新运行代码截取的,变量的内存地址已经改变了,大家不用纠结这里.
  ❓我们思考一下苹果为什么这样设计?因为苹果要隐藏它内部的实现,我们在修改__block修饰的age的值时,从表面看会以为真的是在直接修改age的值,如果不了解底层实现的话,根本就不知道被__block修饰的age已经被包装成了一个对象,而我们实际修改的是age结构体中的age成员的值.

二:__block的内存管理

我们在block如何捕获对象类型的文章中已经知道,如果block访问的是对象类型的变量,那么__main_block_desc_0结构体中会增加copy,dispose两个函数指针,这两个函数会根据变量的修饰符(__strong,__weak,__unretained)进行相应的操作,形成强引用(retain)或者弱引用或者是释放引用的变量.现在我们来研究一下,使用__block修饰的外部变量,在block内部是如何管理的.

声明一个__block修饰的age变量,并且在block内部访问它:

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        //声明 age 变量
        __block int age = 10;

        //声明block
        MYBlock myblock = ^{
            NSLog(@"%d",age);
        };
        //调用block
        myblock();
    }
    return 0;
}

然后我们转成 C++ 代码,看看block底层是如何管理的:

//desc结构体
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};

会发现同访问了对象类型的变量一样,__main_block_desc_0结构体中同样有copy,dispose函数,可能有人会有疑问,因为在block如何捕获对象类型中我们说过,只有在访问对象类型的auto变量时才会生成copy dispose.为什么访问 __block int 时也会产生呢?
在上面我们说过,block在访问__block修饰的变量时,其底层会被封装成__Block_byref_age_0类型,在这个类型存在一个void *__isa成员,所以本质上它就是一个对象类型.

Block内部是如何管理使用__block修饰的变量的呢?

• 在栈上的block,不会对__block产生强引用
• 当block拷贝到堆上时
  1:会调用block内部的copy函数
  2:copy函数内部会调用__main_block_copy_0函数
  3:__main_block_copy_0会调用_Block_object_assign函数对__block变量形成强引用(return)
  也就是说,一旦_Block_object_assign调用,就会对block内部的__block变量产生强引用
  如图:
  

思考一下:__block int age = 10是存放在栈上的,而MYBlock myblock是存放在堆上的,我们使用堆上的地址去指向栈空间肯定是不行的,那block的内部是如何处理这种情况的呢?
结论就是,当栈上的blcok拷贝到堆上时,会把__block修饰的变量一同拷贝到堆上,如图:

思考一下,苹果为什么会这么设计呢?其实这个也很好理解,因为使用__blcok修饰的变量,底层其实被封装成了对象,而我们要在block中使用这个对象,就肯定要对这个对象的引用负责.

既然 block 访问对象类型的变量和访问使用 __block 修饰的变量都会增加copy,dispose函数,那么他们之间有没有区别呢?

他们之间的区别就是:

• 如果使用__block修饰的变量,block内部直接对其强引用
• 如果是对象类型的变量,会根据变量的修饰符__weak , __strong来决定是否强引用

三:block访问 __block 修饰的对象类型

到目前为止,我们讲解了block访问 基本数据类型 (int age) , __block 修饰的基本数据类型 (__block int age), 对象类型 NSObject *object三种情况,下面我们分析一下第四种情况: __blcok 修饰的对象类型.

int main(int argc, const char * argv[]) {
    @autoreleasepool {
    
        Person *person = [[Person alloc]init];
        
        __block Person *blockPerson = person;
        MYBlock block = ^{
            NSLog(@"%@",blockPerson);
        };
        block();
    }
    return 0;
}

我们创建一个Person类,然后使用__block修饰一个person对象,在block 中访问,查看底层代码如下:

// __block 底层对象
struct __Block_byref_blockPerson_0 {
  void *__isa;
__Block_byref_blockPerson_0 *__forwarding;
 int __flags;
 int __size;
 void (*__Block_byref_id_object_copy)(void*, void*);
 void (*__Block_byref_id_object_dispose)(void*);
// __block 中强引用 Person 对象
 Person *__strong blockPerson;
};

// block 底层对象
struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
// block中强引用 __Block_byref_blockPerson_0
  __Block_byref_blockPerson_0 *blockPerson; // by ref
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_blockPerson_0 *_blockPerson, int flags=0) : blockPerson(_blockPerson->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

// block 代码块
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  __Block_byref_blockPerson_0 *blockPerson = __cself->blockPerson; // bound by ref
            NSLog((NSString *)&__NSConstantStringImpl__var_folders_5t_pxd6sp5x6rl9gnk21q2q934h0000gn_T_main_ea4426_mi_0,(blockPerson->__forwarding->blockPerson));
        }

可以看到使用__block修饰的对象底层被封装成了__Block_byref_blockPerson_0类型的对象,__Block_byref_blockPerson_0这个对象类型的结构体中有一个Person *__strong blockPerson成员,强引用着我们在main函数中创建的Person对象,而__main_block_impl_0中的blockPerson又强引用着__Block_byref_blockPerson_0对象,他们的关系如下图:

int main(int argc, const char * argv[]) {
    @autoreleasepool {
    
        Person *person = [[Person alloc]init];
        
        __block __weak Person *blockPerson = person;
        MYBlock block = ^{
            NSLog(@"%@",blockPerson);
        };
        block();
    }
    return 0;
}

查看底层代码:

// __block 底层对象
struct __Block_byref_blockPerson_0 {
  void *__isa;
__Block_byref_blockPerson_0 *__forwarding;
 int __flags;
 int __size;
 void (*__Block_byref_id_object_copy)(void*, void*);
 void (*__Block_byref_id_object_dispose)(void*);
    //这里变成了弱引用,说明这里的引用情况取决于外部变量的修饰符
 Person *__weak blockPerson;
};
// block 底层对象
struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
    //这里还是强引用,说明 __weak 关键字并不会影响这里
  __Block_byref_blockPerson_0 *blockPerson; // by ref
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_blockPerson_0 *_blockPerson, int flags=0) : blockPerson(_blockPerson->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
// main 函数
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  __Block_byref_blockPerson_0 *blockPerson = __cself->blockPerson; // bound by ref

            NSLog((NSString *)&__NSConstantStringImpl__var_folders_5t_pxd6sp5x6rl9gnk21q2q934h0000gn_T_main_4ce55f_mi_0,(blockPerson->__forwarding->blockPerson));
        }

查看底层代码我们发现,block内部对于__Block_byref_blockPerson_0的引用没有变化,但是__Block_byref_blockPerson_0中的blockPerson已经从强引用变成了弱引用.如图: