面试

__block及Block总结

2021-03-04  本文已影响0人  雷霸龙
int i = 0; // 不加__block修饰符将编译错误
void (^blk)() = ^() {
    i = 1; // error！！！！！
};

当我们在Block语法内修改自动变量时，没有加__block修饰符，将会得到一个编译错误
为了保存Block对值的操作，我们可以定义：

int global_var = 1; // 全局变量
static int static_global_var = 2; // 静态全局变量

{
      static int static_var = 3; // 静态局部变量
      void (^blk)() = ^() {
            global_var++;
            static_global_var++;
            static_var++;
            printf("%d\n", global_var); // 输出2
            printf("%d\n", static_global_var); // 输出3
            printf("%d\n", static_var); // 输出4
        };
        blk();
}

这样就可以了，clang一下看看

int global_var = 1;
static int static_global_var = 2;

/ * Block结构体 */
struct __main_block_impl_0 { 
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int *static_var;
 // ......省略构造函数
};
/ * Block方法 */
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  int *static_var = __cself->static_var;  // 注意这里！！！！！

      global_var++;
      static_global_var++;
      (*static_var)++;  // 注意这里！！！！！
      printf("%d\n", global_var);
      printf("%d\n", static_global_var);
      printf("%d\n", (*static_var));
}

可见，对全局变量和静态全局变量的访问依然不作变化，静态局部变量则使用指针对其访问（其指针传递给__main_block_impl_0Block结构体，通过保存的指针在Block语法内来访问自动变量）

我们也可以给变量加上__block修饰符，达到同样的目的

__block修饰符
__block int i = 10; // 不加__block修饰符将编译错误
void (^blk)() = ^() {
   i = 20;
};

添加__block修饰符后，如愿达到了目的，接下来看看发生了什么事情

struct __Block_byref_i_0 {
  void *__isa;
 __Block_byref_i_0 *__forwarding; // 注意这里！！！！！
 int __flags;
 int __size;
 int i;
};

/ * Block结构体 */
struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __Block_byref_i_0 *i; // 注意这里！！！！！
构造函数
__main_block_impl_0(void *fp, 
                    struct __main_block_desc_0 *desc, 
                  __Block_byref_i_0 *_i,
                  int flags=0) : i(_i->__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_i_0 *i = __cself->i; // 注意这里！！！！！
     (i->__forwarding->i) = 20;// 注意这里！！！！！
}


/ * __block int i = 0; 转换后代码*/
__Block_byref_i_0 i = {0, //__isa
                      (__Block_byref_i_0 *)&i,  // __forwarding 注意这里！！！！
                      0,  // flag
                      sizeof(__Block_byref_i_0), // size
                      10 // 变量i
};
image.png

当Block被复制到堆之后，会将自身的__forwarding指针更新，依然指向“最新”的自己，这样就保证了在栈上或者堆上都能正确访问对应变量

image.png

而__forwarding指针的作用正在这里，上文的

 __Block_byref_i_0 *i = __cself->i; 
(i->__forwarding->i) = 20;

__forwarding 保证在栈上或者堆上都能正确访问对应变量

1、什么是Block，Block的本质是什么？
2、为什么block对auto和static变量捕获有差异？

auto自动变量可能会销毁的，内存可能会消失，不采用指针访问；static变量一直保存在内存中，指针访问即可

3、block有哪几种类型？

block的类型，取决于isa指针，可以通过调用class方法或者isa指针查看具体类型，最终都是继承自NSBlock类型

4、如何判断block是哪种类型？
5、对每种类型block调用copy操作后是什么结果？
6、在ARC环境下，编译器会根据情况自动将栈上的block复制到堆上的几种情况？
7、当block内部访问了对象类型的auto变量时，是否会强引用？
8、block的属性修饰词为什么是copy？
9、当block被copy到堆时，对__block修饰的变量做了什么？
10、当block从堆中移除时，对__block修饰的变量做了什么？
11、ARC下如何解决block循环引用的问题？

三种方式：__weak、__unsafe_unretained、__block

.第一种方式：__weak
Person *person = [[Person alloc] init];
//        __weak Person *weakPerson = person;
__weak typeof(person) weakPerson = person;

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

2.第二种方式：__unsafe_unretained
__unsafe_unretained Person *person = [[Person alloc] init];
person.block = ^{
    NSLog(@"age is %d", weakPerson.age);
};

3.第三种方式：__block
__block Person *person = [[Person alloc] init];
person.block = ^{
    NSLog(@"age is %d", person.age);
    person = nil;
};
person.block();
12、MRC下如何解决block循环引用的问题？

两种方式：__unsafe_unretained、__block

1.第一种方式：__unsafe_unretained
__unsafe_unretained Person *person = [[Person alloc] init];
person.block = ^{
    NSLog(@"age is %d", weakPerson.age);
};

2.第二种方式：__block
__block Person *person = [[Person alloc] init];
person.block = ^{
    NSLog(@"age is %d", person.age);
};

Block总结

__block实现原理

  1. 添加__block修饰符后，自动变量i被转换成了结构体__Block_byref_i_0，值被保存在了这个结构体内部
  2. 和上面的对静态自动变量赋值(*static_var)++;，使用指向改变量的指针不同，__block的赋值操作变成了(i->__forwarding->i) = 20;
  3. 从代码转换结果看__Block_byref_i_0 i变量的初始化，__forwarding被赋值(__Block_byref_i_0 *)&i,，也就是__forwarding指针间接访问，这个指针指向自身
上一篇下一篇

猜你喜欢

热点阅读