OC语法 Block

问题:

  1. Block的原理、本质是什么?
  2. Block的分类?
  3. Block的捕获机制?
  4. Blcok内部的内存管理?
  5. __Block的作用?用什么注意点?
  6. Block的属性修饰词为什么是Copy?使用Block有什么注意点?
  7. 循环引用问题
Block的本质

Block本质是封装了函数和函数调用的OC对象。
Block底层实现:

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;
  }
};

成员变量: impl 类型为__block_impl

struct __block_impl {
  void *isa;   //和OC对象一样有个isa指针
  int Flags;  // 当block被copy时,应该执行的操作
  int Reserved; // 保留字段
  void *FuncPtr; // 方法指针
};

成员变量: Desc

static struct __main_block_desc_0 {
  size_t reserved; // 保留字段
  size_t Block_size; // block 的大小
}
Block的分类
  • NSGlobalBlock 保存子数据段
  • NSStackBlock 保存子
  • NSMallocBlock 保存子,NSStackBlockcopy后得到,blcok引用计数加一。
    • MRC NSStackBlockcopy后得到。
    • ARC 系统会根据情况自动调用copy
      • blcok 被强引用。
      • GCD内部的block调用。
      • blcok 在方法中作为参数时。
      • blcok 在方法中作为返回值时。
Block的捕获机制

Block的捕获机制,是因为block是封装的一个函数,在一个函数内部,调用另一个函数内部的变量,超出了变量的作用域,所以需要将变量捕获到blcok内部。

  • 全局变量 :不捕获、全局都可以调用。
    OC代码:
void(^block)(void);
int a = 10;
#import 
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        block = ^{
            NSLog(@"a = %d",a);
        };
         block();
    }
    return 0;
}

clang编译后的C++文件:

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;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {

            NSLog((NSString *)&__NSConstantStringImpl__var_folders_1z_bw1zh_rj5rg3glg1bxmzmnzc0000gp_T_main_1366d6_mi_0,a);
        }

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};
int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
        block = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
         ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
    }
    return 0;
}

可以看到block并没有捕获全局变量a,因为block内部可以随时访问全局变量a

  • 局部变量 : 捕获、但是访问值的方式不同。
    • 局部静态变量: static 修饰的局部变量,内存保存在数据段,作用域为整个app,在另一个函数内可以通过变量地址访问,使用变量,访问值的方式为引用传递

OC代码:

void(^block)(void);
#import 
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        static int a = 10;
        block = ^{
            NSLog(@"a = %d",a);
        };
         block();
    }
    return 0;
}

clang编译后的C++代码:

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, int flags=0) : a(_a) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  int *a = __cself->a; // bound by copy

  NSLog((NSString *)&__NSConstantStringImpl__var_folders_1z_bw1zh_rj5rg3glg1bxmzmnzc0000gp_T_main_ca9917_mi_0,(*a));
}

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};
int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 

        static int a = 10;
        block = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, &a));
         ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
    }
    return 0;
}

可以看出__main_block_impl_0 同样多出了个成员变量a,但是此时成员变量a的类型为指针类型,也可以看出__main_block_func_0()函数在构造结构体__main_block_func_0时传入的参数是&a ,
所以blcok同样捕获了局部静态变量a的值,并保存到__main_block_impl_0成员变量a上,只是成员变量a的类型为指针,这是因为static 修饰后的局部变量a虽然作用域不变,但生存期和全局变量相同,为整个程序,一旦超出局部变量a的作用域,尽管局部变量a的地址还存在,但不能提供变量名a去访问。。为防止,block内部访问局部变量a时,block不在局部变量a的作用域,所以block内部捕获局部变量a的地址,通过地址去访问局部变量a

  • 局部自动变量:auto(默认省略) 修饰的局部变量。内存保存在,作用域为函数内部,超出作用域自动销毁,无法通过变量地址访问,使用变量,需要将变量的值传递进另一个函数,访问值的方式为值传递

基本数据类型
OC代码如下:

void(^block)(void);
#import 
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        int a = 10;
        block = ^{
            NSLog(@"a = %d",a);
        };
         block();
    }
    return 0;
}

clang编译后的C++代码:

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, int flags=0) : a(_a) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  int a = __cself->a; // bound by copy

            NSLog((NSString *)&__NSConstantStringImpl__var_folders_1z_bw1zh_rj5rg3glg1bxmzmnzc0000gp_T_main_8b3967_mi_0,a);
        }

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};
int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 

        int a = 10;
        block = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, a));
         ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
    }
    return 0;
}

可以看出__main_block_impl_0结构体内多了个成员变量int a,且在构造函数__main_block_impl_0 ()构造结构体__main_block_impl_0是传了个参数 int _a,且 : a(_a)_a的值赋给了成员变量a,在看函数__main_block_impl_0 ()函数在构造结构体__main_block_func_0时可以发现
参数_a的值为局部变量a,所以block捕获了局部变量a的值并保存到__main_block_impl_0成员变量a上。

对象数据类型的捕获机制

OC代码:

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

clang编译后的C++代码:

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  Person *p;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, Person *_p, int flags=0) : p(_p) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  Person *p = __cself->p; // bound by copy

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

static void __main_block_dispose_0(struct __main_block_impl_0*src){
  _Block_object_dispose((void*)src->p, 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; 
        Person *p = ((Person *(*)(id, SEL))(void *)objc_msgSend)((id)((Person *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("Person"), sel_registerName("alloc")), sel_registerName("init"));
        void(*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, p, 570425344));
        ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
        NSLog((NSString *)&__NSConstantStringImpl__var_folders_1z_bw1zh_rj5rg3glg1bxmzmnzc0000gp_T_main_277de0_mi_1);
    }
    return 0;
}

可以看出此时的__main_block_impl_0结构体内有成员变量Person *p局部变量 p的值赋值给了成员变量p

注意:Block捕获的变量,基本数据类型:会随blcok的销毁,变量一同销毁。如果是OC对象类型,内存是如何管理的?

Block内部的内存管理
  • 基本数据类型:会随blcok的销毁,变量一同销毁。
  • 对象类型:
    • blcok 底层struct __main_block_desc_0* Desc;结构体内生成
      void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*)
      void (*dispose)(struct __main_block_impl_0*)方法
    • 在Block调用copy时调用void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*)
      • void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*)内部调用
        _Block_object_assign((void*)&dst->p, (void*)src->p, 3/*BLOCK_FIELD_IS_OBJECT*/)根据捕获的变量的指针修饰类型是否为强引用对其进行内存管理。
    • 在blcok销毁时调用void (*dispose)(struct __main_block_impl_0*)
      • void (*dispose)(struct __main_block_impl_0*)内部调用
        _Block_object_dispose((void*)src->p, 3/*BLOCK_FIELD_IS_OBJECT*/)释放捕获的变量。
__block的作用

blcok捕获的变量

  • 局部静态变量: static 修饰的局部变量,内存保存在数据段,作用域为整个app,可以随便修改。
  • 局部自动变量:auto(默认省略) 修饰的局部变量。内存保存在,作用域为函数内部,超出作用域自动销毁,不能访问,也不能修改。

那么如何修改局部自动变量呢?
__block 就是为了实现这一功能。
__block会将修饰的变量封装成OC对象,对象内部保存和变量的变量名、类型一样的变量,这样block捕获的就是封装后的OC对象的值,OC的值不能变,但是OC对象的变量,可以修改,我们在block外部和内部实际访问的事OC对象内的和和变量的变量名、类型一样的变量。

OC语法 Block_第1张图片
image.png

OC语法 Block_第2张图片
image.png

OC语法 Block_第3张图片
__blcok底层实现

OC语法 Block_第4张图片
image.png
OC语法 Block_第5张图片
image.png

__forwarding 指针为什么会如此改变?
当blcok 从栈上拷贝到堆上后,__block变量也被拷贝到堆上。

OC语法 Block_第6张图片
image.png

但是我们要保证,blcok内部修改后的变量,block外部访问的变量值也一样,block
此时是在堆上, __forwarding 指针指向自身(堆上的变量),blcok外部的变量在栈上指向堆上的变量,保证了变量一致。

__block修饰的变量封装的OC对象内部保存的变量的内存管理同block捕获的变量的内存管理一样,__block修饰的变量封装的OC对象内部也有copydispose方法。

Block的属性修饰词为什么是Copy?使用Block有什么注意点?

主要是在MRC下,blcok默认捕获变量后是在栈上,使用copy修饰后进行强引用拷贝到堆上,
ARC下使用strong也是一样的,但是延续了MRC下的习惯,和提醒block是copy到堆上的,也就普遍使用copy修饰。

注意点:循环引用问题

Block的循环引用问题

解决循环引用。

  • __weak 对象释放时block内部,对象会设置为nil。

    OC语法 Block_第7张图片
    image.png

  • __unsafe_unretained unretained不会进行retain操作,但是指针存储的地址不变,会产生野指针。

    OC语法 Block_第8张图片
    image.png

你可能感兴趣的:(OC语法 Block)