iOS -__block

__block 是干什么用的

int val = 10;   
MyBlock block = ^{
    NSLog(@"val = %d",val);
};
block();
//输出
2020-09-22 14:24:47.018497+0800 MyDemo[2987:2658512] val = 10

从一段简单的code说起，在block中修改val的值该怎么办呢？

直接在block中修改会报编译错误Variable is not assignable (missing __block type specifier)

显而易见我们只需要在val变量前加__block关键字即可。

__block int val = 10;
MyBlock block = ^{
    val += 10;
    NSLog(@"val = %d",val);
};
block();
//输出
2020-09-22 14:29:38.065700+0800 MyDemo[2991:2660066] val = 20

现在我们简单的在block中修改了val的值。

__block 原理思考推测

so why？现在到了探究其所以然的时候了。

由于objc封装的较深，我们可以把objc代码转换成c++代码一探究竟

xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m

在main.m文件夹内执行这条命令生成一个main.cpp的c++类

在xcode中打开,在该类中搜索main方法.

/*这个时候使用的是这些code
int val = 10;   
MyBlock block = ^{
    NSLog(@"val = %d",val);
};
block();
*/
int main(int argc, char * argv[]) {
    NSString * appDelegateClassName;
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 

        appDelegateClassName = NSStringFromClass(((Class (*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("AppDelegate"), sel_registerName("class")));
                // 我们声明的auto变量
        int val = 10;
        // 我们声明的block        
        MyBlock block = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, val));
                // block的调用
        ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);

    }
    return UIApplicationMain(argc, argv, __null, appDelegateClassName);
}

我们可以看到__main_block_impl_0这个东西，是我们创建的block在c++里面的实现

typedef void(*MyBlock)(void);

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int val; // 这个地方看到block内部有生成一个对象来保存我们创建的val来使用
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _val, int flags=0) : val(_val) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

对应的__block_impl是block数据结构在c++的实现

struct __block_impl {
  void *isa; // 由此可见block在底层也是一种objc对象
  int Flags;
  int Reserved;
  void *FuncPtr; // block里保存的函数指针
};

我们还能找到我们的NSLog方法__main_block_func_0

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  int val = __cself->val; // 从自身的结构体中取出val对象来使用
    NSLog((NSString*)&__NSConstantStringImpl__var_folders_j2__3l5gw_93rz1_jfmq7r7wwph0000gn_T_main_18d90f_mi_0,
      val);
}

我们从而知道了block会捕获auto类型的变量到自身的结构体，这时候会生成一个新变量val来使用。

虽然捕获到了变量，但是此变量非彼变量，我们并不能在这里修改外部的值。

回想我们遇见的各种类型的block我们发现声明为static的变量不需要加__block就可以直接修改值:

static int staticVal = 10;        
MyBlock block = ^{
    staticVal += 10;
    NSLog(@"staticVal = %d",staticVal);
};
block();
//输出
2020-09-22 14:41:08.103780+0800 MyDemo[3004:2662839] staticVal = 20

那么static的变量是怎么实现的呢？相应的我们可以看看他在block结构体里面到底是怎么做的。

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int *staticVal; // 由此可以看到block拿到了staticVal的指针
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int *_staticVal, int flags=0) : staticVal(_staticVal) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
// block封装的方法
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  int *staticVal = __cself->staticVal; // bound by copy
    (*staticVal) += 10;
  NSLog((NSString *)&__NSConstantStringImpl__var_folders_j2__3l5gw_93rz1_jfmq7r7wwph0000gn_T_main_68799d_mi_0,(*staticVal));
}

拿到了指针就是拿到了他,原来static类型的变量是这么做的，仔细想想明白反正他会一直存在内存中，只要拿到了他的指针就可以在任意时间访问他而不用担心野指针的问题啦。

那么只要我们想办法能在block里面访问auto变量的指针同时保证这个变量不会被释放是不是就能在block里面修改变量了呢？

__block 底层实现验证

现在我们看一下__block的c++实现

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __Block_byref_val_0 *val; // 我们发现这里增加了一个__Block_byref_val_0 的结构体 并命名为val
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_val_0 *_val, int flags=0) : val(_val->__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_val_0 *val = __cself->val; // bound by ref
  (val->__forwarding->val) += 10;// 使用val的__forwarding指针来拿val结构体中的val对象进行赋值
  NSLog((NSString *)&__NSConstantStringImpl__var_folders_j2__3l5gw_93rz1_jfmq7r7wwph0000gn_T_main_00193b_mi_0,      (val->__forwarding->val));
}

对于__Block_byref_val_0可以找到

typedef void(*MyBlock)(void);

struct __Block_byref_val_0 {
 void *__isa;
 __Block_byref_val_0 *__forwarding; // 这个指针指向了自身
 int __flags;
 int __size;
 int val;
};

我们可以看到block使用了一个对象__Block_byref_val_0把val对象包住之后进行使用。

但是这个对象里面的val到底是不是我们定义的那个呢？

这里可以把c++的结构体拷贝到objc中进行一次转换就能拿到这个对象了

struct __Block_byref_val_0 {
 void *__isa; 
 struct __Block_byref_val_0 *__forwarding; 
 int __flags; 
 int __size;
 int val; 
};

struct __block_impl {
  void *isa;
  int Flags;
  int Reserved;
  void *FuncPtr;
};

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
  void (*copy)(void);
  void (*dispose)(void);
};


struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  struct __Block_byref_val_0 *val; // by ref
};

__block int val = 10;

MyBlock block = ^{
    val += 10;
    NSLog(@"val = %d",val);
};

block();

struct __main_block_impl_0 * blockImpl = (__bridge struct __main_block_impl_0 *) block; //这里做一个桥接（对象转换）

NSLog(@"val = %p",&val);

然后我们在debug的断点进来的时候去找blockImpl中val对象的地址,再对比打印出来的val的地址

2020-09-22 16:57:00.771793+0800 MyDemo[3028:2688246] val = 20
(lldb) p/x &(blockImpl->val->val)
(int *) $0 = 0x00000002811c36f8
2020-09-22 16:57:05.581925+0800 MyDemo[3028:2688246] val = 0x2811c36f8

我们可以看到 __main_block_impl_0对象中的val对象的val字段的地址和我们定义的val的地址相同。

至此,我们明白了__block是如何运作的。

__block是如何保证auto变量不被释放的

从上面来看 我们已经能在block内部拿到auto变量的地址了，那么只要能保证block生命周期中这个变量不会被释放掉就可以实现在block中修改他的值了！看起来离我们的目标不远了。

再把目光投向main.cpp文件,我们可以发现三个方法

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

static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->val, 8/*BLOCK_FIELD_IS_BYREF*/);}

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

ARC环境下,系统会自动帮我们把在栈中的访问auto变量的block给copy到堆上去。

在执行copy方法的时候block会执行 __main_block_copy_方法对__main_block_impl_对象进行一次强引用。该方法中执行了_Block_object_assign对包裹val的对象进行retain操作,这里恍然大悟,明白为什么block容易导致循环引用和内存泄漏了。

对应的,在block将要释放的时候执行__main_block_dispose_方法来释放__main_block_impl_对象。

思考

__forwarding指针为什么会指向自己,指向自身的指针是否多余呢？

反过来看，如果在block外部修改掉__block修饰的变量的值时block内部的__Block_byref_val_0的val值会跟随改变吗？会改变的话又是怎么实现的呢？