OC-block底层原理

xq113
179 阅读8分钟

block的本质

  • block本质上也是一个OC对象，它内部也有个isa指针
  • block是封装了函数调用以及函数调用环境的OC对象
  • block的底层结构如下图所示：
  • 我们通过代码来看下block的底层结构

简单的打印block

  • 先创建一个简单的block，用xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m命令将它转化为c++代码
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        ^{
            NSLog(@"------- block");
        };
    }
    return 0;
}
  • 查看生成的cpp文件，找到main函数
int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 

        ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
        //去掉一些强转得到
        //&__main_block_impl_0(__main_block_func_0, 		&__main_block_desc_0_DATA));
        
    }
    return 0;
}
  • 查看__main_block_impl_0的结构
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;  //isa指针，可以看出Block其实就是一个OC对象
  int Flags;
  int Reserved;
  void *FuncPtr;  //函数内存地址
};
---------------------------------------------------------------------------
static struct __main_block_desc_0 {
  size_t reserved;  //保留字段
  size_t Block_size; //__main_block_impl_0结构体所占内存大小
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};

访问外部参数的block

  • 我们创建一个带外部参数的block，查看对应的结构
int c = 15;
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        auto int a = 10;
        static int b = 20;
        NSObject *obj = [[NSObject alloc] init];
        void(^testBlock)(void) = ^{
            NSLog(@"------- block---arg1:%d---arg2:%d---arg3:%d---arg4:%@",a,b,c,obj);
        };
    }
    return 0;
}
  • 查看有外部参数block的cpp文件，找到main函数，去掉一些强转代码，得到下面代码
int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 

        auto int a = 10;
        static int b = 20;
        NSObject *obj = objc_msgSend)((id)(objc_msgSend)((id)objc_getClass("NSObject"), sel_registerName("alloc")), sel_registerName("init"));
        void(*testBlock)(void) = (&__main_block_impl_0(__main_block_func_0, 												 &__main_block_desc_0_DATA, 																		 a, 																		&b, 																	   obj, 															   570425344));
    }
    return 0;
}
  • 查看__main_block_impl_0的结构
struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int a;
  int *b;
  NSObject *obj;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _a, int *_b, NSObject *_obj, int flags=0) : a(_a), b(_b), obj(_obj) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
---------------------------------------------------------------------------
struct __block_impl {
  void *isa;  //isa指针，可以看出Block其实就是一个OC对象
  int Flags;
  int Reserved;
  void *FuncPtr;  //函数内存地址
};
---------------------------------------------------------------------------
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};
  • 发现block访问不同的参数会生成不同的代码。

block的变量捕获（capture）

  • 为了保证block内部能够正常访问外部的变量，block有个变量捕获机制。

auto变量的捕获

  • 通过对上述代码的观察发现auto变量auto int a在struct __main_block_impl_0是以int a;的方式保存的。

static变量的捕获

  • static变量static int b在struct __main_block_impl_0是以int *b;的方式保存的。

对象类型的auto变量

  • 当block内部访问了对象类型的auto变量时
  • 如果block是在栈上，将不会对auto变量产生强引用
    如果block被拷贝到堆上 会调用block内部的copy函数 copy函数内部会调用_Block_object_assign函数 _Block_object_assign函数会根据auto变量的修饰符（__strong、__weak、__unsafe_unretained）做出相应的操作，形成强引用（retain）或者弱引用
  • 如果block从堆上移除
    会调用block内部的dispose函数
    dispose函数内部会调用_Block_object_dispose函数
    _Block_object_dispose函数会自动释放引用的auto变量（release）

此处需要注意的是，其实在OC中有个默认的关键字auto，在我们创建局部变量的时候，会默认在局部变量前加上auto关键字进行修饰。auto关键字的含义就是它所修饰的变量会自动释放，也表示着它所修饰的变量会存放到栈空间，系统会自动对其进行释放。

总结

  • 当block访问的是auto类型的局部变量时，会将局部变量捕获到block内部的结构体中，并且是直接捕获变量的值。
  • 当block访问的是static类型的静态变量时，会将静态变量捕获到block内部的结构体中，并且捕获的是静态变量的地址。
  • 当block访问的是全局变量时，不会进行捕获，直接进行访问。

block的类型

  • block有3种类型，可以通过调用class方法或者isa指针查看具体类型，最终都是继承自NSBlock类型。
  • 分别是_NSGlobalBlock_、__NSStackBlock__和_NSMallocBlock_，这三种类型分别存放在.data区、栈区和堆区。对应的结构图如下
  • 对应的表格如下
class方法返回类型isa指向类型
_NSGlobalBlock__NSConcreteGlobalBlock
_NSStackBlock__NSConcreteStackBlock
_NSMallocBlock__NSConcreteMallocBlock
  • 通过代码打印查看不同类型的block，代码如下
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        auto int a = 10;
        void(^testBlock)(void) = ^{
            NSLog(@"------- block---arg1:%d",a);
        };
        NSLog(@"block type:%@\n%@\n%@",[testBlock class],[(^{}) class],[(^{NSLog(@"------- block---arg1:%d",a);}) class]);
    }
    return 0;
}
---------------------------------------------------------------------------
Block[49219:5809794] block type:__NSMallocBlock__
__NSGlobalBlock__
__NSStackBlock__
  • 由此可以得出以下结论
block的类型block执行的操作
_NSGlobalBlock_没有访问auto类型的变量
_NSStackBlock_访问了auto类型的变量
_NSMallocBlock___NSStackBlock__类型的block执行了copy操作

block的copy

  • _NSGlobalBlock_、__NSStackBlock__和__NSMallocBlock__三种类型的block分别存放在了数据区、栈区和堆区。将三种类型的block分别进行copy操作之后，产生的结果如下：
  • 对__NSGlobalBlock__的block进行copy操作，什么也不会发生，生成的还是__NSGlobalBlock__类型的block
  • 对__NSStackBlock__类型的block进行操作，会将block从栈上复制一份到堆中，生成__NSMallocBlock__类型的block
  • 对__NSMallocBlock__类型的block进行copy操作，此block的引用计数会加1
  • 在ARC环境下，编译器会根据情况自动将栈上的block复制到堆上，比如以下情况
    block作为函数返回值时
    将block赋值给__strong指针时
    block作为Cocoa API中方法名含有usingBlock的方法参数时
    block作为GCD API的方法参数时

__block修饰符

  • 使用block时，如果block中访问到了外部被auto修饰的变量，我们经常使用到__block来修饰外部变量，它的主要作用就是能够让我们在block内部来修改外部变量的值，当然，block只能用来修饰auto变量，不能用来修饰全局变量和静态变量。
  • 编译器会将__block变量包装成一个对象，查看cpp代码：
struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int *b;
  NSObject *obj;
  __Block_byref_a_0 *a; // by ref __block修饰的变量 ：__block auto int a = 10;;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int *_b, NSObject *_obj, __Block_byref_a_0 *_a, int flags=0) : b(_b), obj(_obj), a(_a->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
---------------------------------------------------------------------------
struct __Block_byref_a_0 {
  void *__isa;
__Block_byref_a_0 *__forwarding;
 int __flags;
 int __size;
 int a;
};

__block的内存管理

  • 当block在栈上时，并不会对__block变量产生强引用

  • 当block被copy到堆时
    会调用block内部的copy函数
    copy函数内部会调用_Block_object_assign函数
    _Block_object_assign函数会对__block变量形成强引用（retain）

  • 当block从堆中移除时
    会调用block内部的dispose函数
    dispose函数内部会调用_Block_object_dispose函数
    _Block_object_dispose函数会自动释放引用的__block变量（release）

__block的__forwarding指针

  • __block修饰的auto变量所对应的结构体如下

  • 在结构体中有一个__forwarding指针指向自己，在后续访问__block变量的时候也是通过__forwarding指针来进行访问

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  __Block_byref_a_0 *a = __cself->a; // bound by ref
  int *b = __cself->b; // bound by copy
  NSObject *obj = __cself->obj; // bound by copy

            NSLog((NSString *)&__NSConstantStringImpl__var_folders_13_ztl_wzln5357kbjwzx2pgrrw0000gp_T_main_6cc69c_mi_0,(a->__forwarding->a),(*b),c,obj);
        }
  • 当block在栈上时，__block变量也存放在栈上，它内部的__forwarding指针指向它本身
  • 当block被复制到堆上之后，block所引用的__block变量也会被复制到堆上，这样在栈上和堆上各存在一份__block变量，此时将栈上__block变量中的__forwarding指针指向堆上__block变量的地址，同时，堆上的__block变量中的__forwarding指针指向它本身，那么此时，不管我们是访问栈上__block变量中的属性值还是堆上__block变量中的属性值，都是通过__forwarding指针访问到堆上的__block变量。

对象类型的auto变量、__block变量

  • 当block在栈上时，对它们都不会产生强引用

  • 当block拷贝到堆上时，都会通过copy函数来处理它们

  • __block变量（假设变量名叫做a）

_Block_object_assign((void*)&dst->a, (void*)src->a, 8/*BLOCK_FIELD_IS_BYREF*/);
  • 对象类型的auto变量（假设变量名叫做p）
_Block_object_assign((void*)&dst->p, (void*)src->p, 3/*BLOCK_FIELD_IS_OBJECT*/);
  • 当block从堆上移除时，都会通过dispose函数来释放它们
__block变量（假设变量名叫做a）
_Block_object_dispose((void*)src->a, 8/*BLOCK_FIELD_IS_BYREF*/);
  • 对象类型的auto变量（假设变量名叫做p）
_Block_object_dispose((void*)src->p, 3/*BLOCK_FIELD_IS_OBJECT*/);

被__block修饰的对象类型

  • 当__block变量在栈上时，不会对指向的对象产生强引用

  • 当__block变量被copy到堆时
    会调用__block变量内部的copy函数
    copy函数内部会调用_Block_object_assign函数
    _Block_object_assign函数会根据所指向对象的修饰符（__strong、__weak、__unsafe_unretained）做出相应的操作，形成强引用（retain）或者弱引用（注意：这里仅限于ARC时会retain，MRC时不会retain）

  • 如果__block变量从堆上移除
    会调用__block变量内部的dispose函数
    dispose函数内部会调用_Block_object_dispose函数
    _Block_object_dispose函数会自动释放指向的对象（release）

循环引用问题

block循环引用的问题

  • 在使用block时，如果block作为一个对象的属性，并且在block中也使用到了这个对象，则会产生循环引用，导致block和对象相互引用，无法释放。Demo如下
typedef void(^testBlock)(void);
@interface Person : NSObject

@property(nonatomic, copy)NSString *name;
@property(nonatomic, copy)testBlock block;

@end

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

解决循环引用问题 - ARC

  • 使用__weak来修饰对象
__weak typeof(person) weakPerson = person;
person.block = ^{
    NSLog(@"%@",weakPerson.name);
};
  • 使用__unsafe_unretained来修饰对象
__unsafe_unretained Person *weakPerson = person;
person.block = ^{
    NSLog(@"%@",weakPerson.name);
};

__weak和__unsafe_unretained的区别 __weak和__unsafe_unretained最终的效果都是能shi使block不对外部访问的对象形成强引用，而是形成弱引用。也就是说外部对象的引用计数不会增加。但是__weak和__unsafe_unretained也有区别，__weak在对象被销毁后会自动将weak指针置为nil，而__weak和__unsafe_unretained修饰的对象在被销毁后，指针是不会被清空的，如果后续访问到了这个指针，会报野指针的错误，因此在遇到循环引用的时候，优先使用__weak来解决。

  • 用__block解决（必须要调用block）
__block Person *weakPerson = person;
person.block = ^{
   	 NSLog(@"%@",weakPerson.name);
     weakPerson = nil;
};
person.block();

解决循环引用问题 - MRC

  • 使用__unsafe_unretained来修饰对象
__unsafe_unretained Person *weakPerson = person;
person.block = ^{
    NSLog(@"%@",weakPerson.name);
};
  • 使用__unsafe_unretained来修饰对象
__block Person *weakPerson = person;
person.block = ^{
    NSLog(@"%@",weakPerson.name);
};
avatar
文章
阅读
粉丝