Objective-C Block本质

2021-02-25 本文已影响0人 lieon

Block本质

block本质是一个OC对象，它内部也有个isa指针
block是封装了函数调用以及函数调用环境的OC对象
将以下代码编译为C++源码 xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m

void (^block)(void);
void test()
{
    int age = 10;
    static int height = 10;
    block = ^{
        NSLog(@"age is %d, height is %d", age, height);
    };
    age = 20;
    height = 20;
}

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        test();
        block();
  }
}

clang编译之后的C++代码

struct __block_impl {
void *isa;
int Flags;
int Reserved;
  // 指向方法入口地址
void *FuncPtr;
};

// block对象
struct __test_block_impl_0 {
struct __block_impl impl;
struct __test_block_desc_0* Desc;
int age;
int *height;
__test_block_impl_0(void *fp, struct __test_block_desc_0 *desc, int _age, int *_height, int flags=0) : age(_age), height(_height) {
  impl.isa = &_NSConcreteStackBlock;
  impl.Flags = flags;
  impl.FuncPtr = fp;
  Desc = desc;
}
};

// test函数中，block的函数体，执行的具体方法
static void __test_block_func_0(struct __test_block_impl_0 *__cself) {
int age = __cself->age; // bound by copy
int *height = __cself->height; // bound by copy
NSLog((NSString *)&__NSConstantStringImpl__var_folders_fc_j144208d3nl9m4ql0ryqmghh0000gn_T_main_0d86ab_mi_0, age, (*height));
}

// test函数中，block的描述信息
static struct __test_block_desc_0 {
size_t reserved;
size_t Block_size;
} __test_block_desc_0_DATA = { 0, sizeof(struct __test_block_impl_0)};

void test()
{
  int age = 10;
  static int height = 10;

  block = ((void (*)())&__test_block_impl_0((void *)__test_block_func_0, &__test_block_desc_0_DATA, age, &height)); // __test_block_impl_0

  age = 20;
  height = 20;
}

int main(int argc, const char * argv[]) {
  /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
      test();
      // block->FuncPtr(block); 为什么不是block->impl.FuncPtr,因为block对象首地址就是impl的地址
      ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
  }
  return 0;
}

综上代码可以看出Block的C++布局：
- void *isa;
- int Flags;
- int Reserved;
- void *FuncPtr; 指向block的函数体
- struct __test_block_desc_0* Desc;（指向的内存信息包括 size_t reserved，size_t Block_size）
- 捕获变量

block的变量捕获

从以上void test()函数看出

__test_block_impl_0(void *fp, struct __test_block_desc_0 *desc, int _age, int *_height, int flags=0) : age(_age), height(_height) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }

局部变量auto变量捕获到block，是通过值传递方式，给block对象
局部变量static变量捕获到block内部，传递是一个指针，一个地址
全部变量不会不会到block内部，直接访问

block的类型

block有三种类型，可以通过调用class方法或者isa指针查看具体类型，最终都是继承自NSBlock类型
- NSGlobalBlock （ _NSConcreteGlobalBlock ），环境：没有访问auto变量
- NSStackBlock （ _NSConcreteStackBlock ）,环境：访问了auto变量
- NSMallocBlock （ _NSConcreteMallocBlock ）,环境： NSStackBlock 调用了Copy

image.png

    NSLog(@"%@", [block class]); // __NSGlobalBlock__
    NSLog(@"%@", [[block class] superclass]); //  NSBlock
    NSLog(@"%@", [[[block class] superclass] superclass]); // NSObject
    NSLog(@"%@", [[[[block class] superclass] superclass] superclass]); // null

  int a = 10;
  // 堆：动态分配内存,需要程序员申请申请，也需要程序员自己管理内存
  void (^block1)(void) = ^{
         NSLog(@"Hello");
  };
  int age = 10;
  void (^block2)(void) = ^{
        NSLog(@"Hello - %d", age);
   };
   NSLog(@"%@ % @ %@", [block1 class], [block2 copy], [^{
       NSLog(@"%d", age);
   } class]); // __NSGlobalBlock__ __NSMallocBlock__ __NSStackBlock__

  // Global：没有访问auto变量 - 数据段
    void (^block1)(void) = ^{
        NSLog(@"block1---------");
    };
    
    // Stack：访问了auto变量 - 栈s
    int age = 10;
    void (^block2)(void) = ^{
        NSLog(@"block2---------%d", age);
    };
    // Malloc block
    NSLog(@"%p", [block2 copy]);

 // NSStackBlock   - 堆：内存管理由h程序员销毁管理
    int age = 10;
    block = ^{
        NSLog(@"block---------%d", age);
    };
    // 在test2外部执行block，此时的输出 272632984，为什么不是10，因为test2执行完毕block对应的c++对象在栈上的内存被回收
    // 要想输出结果为仍然为10，可以调用copy方法，将block对象的内存从栈复制到堆上，堆上的内存由程序员手动管理

block的copy

在ARC环境下，编译器会根据情况自动将粘上的block复制到堆上：
- block作为函数返回值时
- 将block赋值给__strong指针时
- block作为Cocoa API中方法名含有usingBlock的方法参数
- block作为GCD API的方法参数时
ARC下block属性的建议写法
```
@property (copy, nonatomic) void (^block)(void);
```
- 以下代码，bock访问了 auto变量，类型为StackBlock，在栈上, 但是输出的结果却是 NSMallocBlock，原因是在ARC环境下，编译器会把block对象拷贝到堆上，相当于自动调用了copy方法，如果是MRC的环境，输出的类型是NSStackBlock
```
int age = 10;
 MJBlock block = ^{
    NSLog(@"---------%d", age);
  };
  NSLog(@"%@", [block class]); // ARC：__NSMallocBlock__，   MRC: __NSStackBlock__
```

block访问了对象类型的auto变量

当block内部访问了对象类型的auto变量时

如果block在栈上，将不会对auto变量产生强引用

MJBlock block;
{
  MJPerson *person = [[MJPerson alloc] init];
  person.age = 10;
  int age = 10;
  block = ^{
      NSLog(@"---------%d --%d", person.age, age);
  };
   [person release];
   //MRC person 将会在该作用域结束后释放， block的类型为__NSStackBlock__
 }
 NSLog(@"------: %@", [block class]); // __NSStackBlock__

如果block被拷贝堆上
- 会调用block内部的copy函数
- copy函数内部会调用_Block_object_assign函数
- _Block_object_assign函数会根据auto变量修辞符（__strong、__weak、__unsafe_unretained）做出相应的操作，形成强引用或者弱引用

  MJBlock block;
  {
      MJPerson *person = [[MJPerson alloc] init];
       person.age = 10;
       int age = 10;
          block = ^{
              NSLog(@"---------%d --%d", person.age, age);
          };
      }
      NSLog(@"------: %@", [block class]); // __NSMallocBlock__

将上述代码编译为C++代码

    struct __main_block_impl_0 {
       struct __block_impl impl;
       struct __main_block_desc_0* Desc;
       MJPerson *person;
       int age;

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

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
   MJPerson *person = __cself->person; // bound by copy
   int age = __cself->age; // bound by copy
   NSLog((NSString *)&__NSConstantStringImpl__var_folders_fc_j144208d3nl9m4ql0ryqmghh0000gn_T_main_8479c1_mi_0, ((int (*)(id, SEL))(void *)objc_msgSend)((id)person, sel_registerName("age")), 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);
  }

   static void __main_block_dispose_0(struct __main_block_impl_0*src) {
      _Block_object_dispose((void*)src->person, 3);
 }
// 创建一个结构体，并声明初始化变量__main_block_desc_0_DATA
  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[]) { { __AtAutoreleasePool __autoreleasepool;
     MJBlock block;
     {
         MJPerson *person = ((MJPerson *(*)(id, SEL))(void *)objc_msgSend)((id)((MJPerson *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("MJPerson"), sel_registerName("alloc")), sel_registerName("init"));
         ((void (*)(id, SEL, int))(void *)objc_msgSend)((id)person, sel_registerName("setAge:"), 10);
         int age = 10;
         block = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, person, age, 570425344));
     }
     NSLog((NSString *)&__NSConstantStringImpl__var_folders_fc_j144208d3nl9m4ql0ryqmghh0000gn_T_main_8479c1_mi_1, ((Class (*)(id, SEL))(void *)objc_msgSend)((id)block, sel_registerName("class")));
 }
   return 0;
 }

如果block从堆上移除
- 会调用block内部的dispose函数
- dispose函数内部会调用_Block_object_dispose函数

_Block_object_dispose函数会自动释放引用的auto变量

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

image.png

OC为C++代码时,__weak问题解决

在使用clang转换OC为C++代码时，可能会遇到以下问题
- cannot create __weak reference in file using manual reference
解决方案：支持ARC、指定运行时系统版本，比如
- xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc -fobjc-arc -fobjc-runtime=ios-8.0.0 main.m

__block修饰符

__block可以用于解决block内部无法修改auto变量值的问题
__block不能修饰全局变量，静态变量(static)
编译器会将__block变量包装成一个对象

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        int no = 20;
        /**
         对__block对象直接产生强引用
         对非__block对象产生的引用取决于它的修饰符 __weak产生弱引用， __strong产生强引用
         
         struct __main_block_impl_0 {
           struct __block_impl impl;
           struct __main_block_desc_0* Desc;
           int no;
           NSObject *__weak weakObject;
           __Block_byref_age_0 *age; // by ref
             }
         */
        __block int age = 10;
        
        NSObject *object = [[NSObject alloc] init];
        __weak NSObject *weakObject = object;
        
        MJBlock block = ^{
            age = 20;
            
            NSLog(@"%d", no);
            NSLog(@"%d", age);
            NSLog(@"%p", weakObject);
        };
        
        struct __main_block_impl_0* blockImpl = (__bridge struct __main_block_impl_0*)block;
                block();
    }
    return 0;
}


typedef void (*MJBlock) (void);
struct __Block_byref_age_0 {
    void *__isa;
    __Block_byref_age_0 *__forwarding;
    int __flags;
    int __size;
    int age;
};

struct __main_block_impl_0 {
    struct __block_impl impl;
    struct __main_block_desc_0* Desc;
    int no;
    NSObject *__weak weakObject;
    __Block_byref_age_0 *age; // by ref
    
    __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _no, NSObject *__weak _weakObject, __Block_byref_age_0 *_age, int flags=0) : no(_no), weakObject(_weakObject), age(_age->__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_age_0 *age = __cself->age; // bound by ref
    int no = __cself->no; // bound by copy
    NSObject *__weak weakObject = __cself->weakObject; // bound by copy
    /// age->__forwarding->age这么做的原因是为了让age始终被正确访问，block会被拷贝到堆上
    (age->__forwarding->age) = 20;
}

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

static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->age, 8/*BLOCK_FIELD_IS_BYREF*/);_Block_object_dispose((void*)src->weakObject, 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;
        
        int no = 20;
        
        __attribute__((__blocks__(byref))) __Block_byref_age_0 age = {(void*)0,(__Block_byref_age_0 *)&age, 0, sizeof(__Block_byref_age_0), 10};
        
        NSObject *object = ((NSObject *(*)(id, SEL))(void *)objc_msgSend)((id)((NSObject *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("NSObject"), sel_registerName("alloc")), sel_registerName("init"));
        __attribute__((objc_ownership(weak))) NSObject *weakObject = object;
        
        MJBlock block = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, no, weakObject, (__Block_byref_age_0 *)&age, 570425344));
        ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
    }
    return 0;
}

image.png

可以看到在block中访问了 __block 修辞的age的变量，age在block对象中被包装成了 __Block_byref_age_0 类的指针，指向__Block_byref_age_0对象的第一个元素的地址__isa，从__Block_byref_age_0这个类结构可以看出，里面的__forwarding指针，指向该类，可以通过该指针访问age变量
image.png
__blokc修辞的auto变量（基础数据类型）的内存管理
- 当block在栈上时，并不会对__block变量产生强引用, 在ARC环境下，编译器会将__NSStackBlock类型的block自动执行一次copy操作到堆上
- 当block被copy到堆上时
  - 回调用block内部的copy函数
  - copy函数内部会调用_Block_object_assign函数
    -_Block_object_assig函数会对__block变量形成强引用(retain)
  - 对非__block对象产生的引用取决于它的修饰符 __weak产生弱引用， __strong产生强引用
    
    image.png
当block从堆中移除时
- 会调用block内部的dispose函数
- dispose函数会调用 _Block_object_dispose函数
- _Block_object_dispose函数会自动释放引用的_blcok变量

image.png

block的forwarding指针

struct __Block_byref_age_0 {
  void *__isa; // 8
  __Block_byref_age_0 *__forwarding; // 8
 int __flags; // 4
 int __size; // 4
 int age; // 0x000000010300da68
};

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
    __Block_byref_age_0 *age = __cself->age; // bound by ref
    int no = __cself->no; // bound by copy
    NSObject *__weak weakObject = __cself->weakObject; // bound by copy
    /// age->__forwarding->age这么做的原因是为了让age始终被正确访问，block会被拷贝到堆上
     (age->__forwarding->age) = 20;
}

__forwarding指针指向的是自身的地址
当block对象被复制到堆上时，__forwarding指针对上的结构体
采用这种方式就能保证始终访问到正确位置的变量的age

image.png

对象类型的auto变量，__block变量内存管理的总结

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

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

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

_Block_object_assign((void*)&dst->a, (void*)src->a, 8/*BLOCK_FIELD_IS_BYREF*/);

对象类型的auto变量

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

当block从堆上移除时，都会通过dispose函数来释放它们

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*/);
    _Block_object_assign((void*)&dst->a, (void*)src->a, 8/*BLOCK_FIELD_IS_BYREF*/);
}
static void __main_block_dispose_0(struct __main_block_impl_0*src) {
    _Block_object_dispose((void*)src->person, 3/*BLOCK_FIELD_IS_OBJECT*/);
    _Block_object_dispose((void*)src->a, 8/*BLOCK_FIELD_IS_BYREF*/);
}

被被__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）

int main(int argc, const char * argv[]) {
  @autoreleasepool {
      MJPerson *person = [[MJPerson alloc] init];
      __strong MJPerson *strogPerson = person;
      __weak MJPerson *weakPerson = person;
      MJBlock block = ^{
          NSLog(@"%p - %p", strogPerson, weakPerson);
      };
      block();
  }
  return 0;
}

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  MJPerson *__strong strogPerson;
  MJPerson *__weak weakPerson;
}

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

  static void __main_block_dispose_0(struct __main_block_impl_0*src) {
      _Block_object_dispose((void*)src->strogPerson, 3/*BLOCK_FIELD_IS_OBJECT*/);
      _Block_object_dispose((void*)src->weakPerson, 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};

block循环引用问题

image.png

所以为了解决循环引用问题就是将其中的一个引用箭头变为虚线，产生弱引用

self.block = ^{
        NSLog(@"age is %d", self.age);
  };

struct __MJPerson__test_block_impl_0 {
    struct __block_impl impl;
    struct __MJPerson__test_block_desc_0* Desc;
    MJPerson *const __strong self;
};

相当于堆上的block对象持有MJPerson * self指针，该指针指向MJPerson的堆空间内存，同时MJPerson对象持有该block对象，所以就造成了循环引用

image.png

解决循环引用问题

用__weak, __unsafe_unretained解决，用weak时，相当于block对象里面的MJPerson* self变为弱指针，当指向的堆空间被销毁时，weak修饰的指针变量也会被设置为nil, 但是__unsafe_unretained修饰的指针变量不会被设置为nil，所以如果再次使用改指针变量访问时就会出现坏内存地址崩溃

__weak typeof(self) weakSelf = self;
  self.block = ^{
      NSLog(@"age is %d", weakSelf.age);
  };
 // 使用weak时
 struct __MJPerson__test_block_impl_0 {
    struct __block_impl impl;
    struct __MJPerson__test_block_desc_0* Desc;
    MJPerson *const __weak weakSelf;
};

// 使用__unsafe_unretained时
struct __MJPerson__test_block_impl_0 {
    struct __block_impl impl;
    struct __MJPerson__test_block_desc_0* Desc;
    MJPerson *const __unsafe_unretained weakSelf;
  };

用__block解决，必须调用block，同时必选在block内手动设置nil, 我们知道__block对应的c++代码是会把self进行一个对象的包装，通过访问其内部的farwarding指针获取到对象内存，在block内存手动将其设置为nil，就相当于__block对象不持有self

  __block id weakSelf = self;
    self.block = ^{
        NSLog(@"age is %@", weakSelf);
        weakSelf = nil;
    };
    self.block();


struct __MJPerson__test_block_impl_0 {
    struct __block_impl impl;
    struct __MJPerson__test_block_desc_0* Desc;
    __Block_byref_weakSelf_0 *weakSelf; // by ref
};

struct __Block_byref_weakSelf_0 {
  void *__isa;
__Block_byref_weakSelf_0 *__forwarding;
 int __flags;
 int __size;
 void (*__Block_byref_id_object_copy)(void*, void*);
 void (*__Block_byref_id_object_dispose)(void*);
 __strong id weakSelf;
};

image.png

一些问题

block为什么要进行外部变量捕获？
为何要将block转为一个类？用函数指针不行吗？
- block本身存在一种操作那个，就是外部局部变量的捕获，需要将block相关的动效保存起来，OC都会转为C++代码，C++中能同时保存方法和变量的就是类；函数和函数指针办不到外部局部变量的捕获的功能
为何static局部变量进行的是指针捕获? 值捕获不行吗？
- 首先要明白：static局部变量具有的特性：仍然是局部变量，加上static修饰后，局部变量的生命周就变得跟全局变量一样（static局部变量的存储区域放在了全局，但是作用域仍然是函数调用栈的作用域，全局的变量在程序运行过程中，只会被声明及初始化一次，并且是在程序结束时才销毁），基于static变量的特性，是局部变量所以就会被捕获，在全局区，只能声明和初始化一次，并且随时访问到的是同一块内存空间，所以最简单的做法就是将static局部变量的内存地址保存下来，通过这个地址随时访问那一块内存空间

Objective-C Block本质

Block本质

block的变量捕获

block的类型

block的copy

block访问了对象类型的auto变量

OC为C++代码时,__weak问题解决

__block修饰符

block的forwarding指针

对象类型的auto变量，__block变量内存管理的总结

被被__block修饰的对象类型的内存管理情况

block循环引用问题

解决循环引用问题

一些问题

猜你喜欢

热点阅读

Objective-C Block本质

Block本质

block的变量捕获

block的类型

block的copy

block访问了对象类型的auto变量

OC为C++代码时,__weak问题解决

__block修饰符

__block的__forwarding指针

对象类型的auto变量，__block变量内存管理的总结

被被__block修饰的对象类型的内存管理情况

block循环引用问题

解决循环引用问题

一些问题

猜你喜欢

热点阅读

block的forwarding指针