ios学习--block深度解析

最新推荐文章于 2025-04-29 18:18:54 发布

zzzzzdddddxxxxx

最新推荐文章于 2025-04-29 18:18:54 发布

阅读量903

点赞数 1

分类专栏： block iOS

iOS 同时被 2 个专栏收录

261 篇文章

订阅专栏

block

2 篇文章

订阅专栏

1. block的本质是一个Objective-C的对象，为什么这么说？

在Objective-C中，runtime会在运行时根据对象的isa指针的指向，来度额定这个对象的类型，也可以认为一个对象，它具有isa指针，就是一个OC对象

2. 你怎么知道block有isa指针呢，我们可以通过clang命令将来看block的实现

//测试代码
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        void(^blk)(void)=^{
            NSLog(@"hello lx");
        };

    }
    return 0;
}

   
   1
2
3
4
5
6
7
8
9
10
11
   
   1
2
3
4
5
6
7
8
9
10
11

转化后：block对象被编译器转化成了一个__main_block_impl_0 的结构体如下

struct __main_block_impl_0 {
  struct __block_impl impl;//block实现的相关信息
  struct __main_block_desc_0* Desc;//block的描述信息
  __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;
  }
};
   
   1
2
3
4
5
6
7
8
9
10
   
   1
2
3
4
5
6
7
8
9
10

这个结构体由三部分组成impl的结构体+Desc的结构体指针+构造函数，构造函数是用来对结构体做初始化的，剩下的那两个结构体对应的实现如下

//impl的类型，block的相关实现信息
struct __block_impl {
  void *isa;//看到了isa指针，说明block是一个isa指针，对于他的类后面会讲到
  int Flags;//标志
  int Reserved;//
  void *FuncPtr;//函数的实现，指向了block变量所对应的函数的实现地址
};
//对于block的描述信息
struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};
   
   1
2
3
4
5
6
7
8
9
10
11
12
   
   1
2
3
4
5
6
7
8
9
10
11
12

总结一下上面的代码：

block会被编译器转化为__main_block_impl_0的结构体，这个结构体由三部分组成：存储block的相关实现信息的_block_impl的结构体impl以及存储block的描述信息的__main_block_desc_0的结构体指针Desc以及用来对block做初始化的构造方法，其中impl中的isa的成员说明了block是一个oc对象，还有一个一个函数指针指向了block的实现

3. block：其实相当于c语言中的匿名函数，他可以访问外部变量或者对象

block这个匿名函数和普通函数的区别

1.没有函数名，最纯洁的block ^{ printf("hello"); };，最纯洁的函数最起码要有个函数名
2. 带有脱字符’^’
3.不管c语言还是oc函数都不支持函数嵌套，但是block实现了这个功能，它相当于一个函数，但是他的视线却是在另外一个函数的内部。

可以访问的类型

#

自动变量：就是局部变量。访问局部变量相当于函数调用时的值传递，不允许修改：当访问了外部的变量，他会把他访问到的自动变量作为结构体成员添加到他的结构体当中，而且和原变量同名同值，不能修改的原因是，他们除了值一样没有练习，上面说到，block相当于一个函数，两个函数里面有仙童的局部变量，一个变了并不会对另外一个产生影响，所以编译器干脆就禁止了，实现如下

//block访问外部自动变量
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;
  }
};
   
   1
2
3
4
5
6
7
8
9
10
11
12
   
   1
2
3
4
5
6
7
8
9
10
11
12

#

2 . 静态变量，在其作用范围内只有一分内存，对其可读可写。相当于函数调用时的地址传递，block会将它访问到的外部静态变量的地址添加到自己的结构体成员中，有了地址，改值又有什么不可以呢，实现如下

//截获静态变量值
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;
  }
};
   
   1
2
3
4
5
6
7
8
9
10
11
12
   
   1
2
3
4
5
6
7
8
9
10
11
12

#

3 . 全局变量：在全局可以访问到的，在全局符号表中，与在block外访问没有区别，可读可写
对于静态、全局变量的区别，可以戳这里我觉得可以点

#

4 .对象，block可以读对象，不能修改对象指针的指向。

#

5 .对象的属性：可读可写

4. 如何让block可以修改截获的自动变量的值

4. 修改block所截获的外部变量的值

上面说到：block不可以修改自动变量或者对象的指向，这个时候，__block就像一个救世主一样出现在了我们面前，__block是如何实现修改自动变量值的，看一下他的实现



struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __Block_byref_a_0 *a; //多了一个__Block_byref_a_0结构体指针
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_a_0 *_a, int flags=0) : a(_a->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
//被block修饰的自动变量被这样的一个结构体指针保存了其地址
struct __Block_byref_a_0 {
  void *__isa;//指向其所对应的类
__Block_byref_a_0 *__forwarding;//指向自身
 int __flags;
 int __size;
 int a;//自动变量的值
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  __Block_byref_a_0 *a = __cself->a; // bound by ref

            (a->__forwarding->a) = 20;
            printf("%d",(a->__forwarding->a));
        }

   
   1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
   
   1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

从上面可以看出，当用__block修饰自动变量的时候，这个变量变成了一个struct __Block_byref_a_0的结构体实例，这个结构体有一个指向自身的指针，forwarding，来保证这个变量不管在什么位置都能被正确访问到，（后面会详细解释）
修改变量的过程：impl会根据自己保存的指向struct __Block_byref_a_0的结构体实例的指针，根据这个指针找到farWarding指针找到自己，在找到里面存储的自动变量，修改他的值。

5. block的存储域

在前面，我们发现block本质是一个对象，他有一个isa指针，指向其所对应的类，那么他所对应的类是什么呢，这就牵扯到block的存储域了

block的存储于域有三种类型,其中isa指针指向这三种中的其中一种
1. _NSConcreteStackBlock:存储在栈上
2. _NSConcreteGlobalBlock：存储在数据区
3. _NSConcretMallocBlock：存储在堆上

对于这三种类型的使用情况

_NSConcreteGlobalBlock:
1. 凡是所有的全局block都存储在数据区
2. 如果block中没有截获自动变量，block也在数据区

_NSConcreteStackBlock:
1. MRC：默认在栈区，block生命周期与其作用域相关
2.ARC：大多数ARC情况下的block是存储在堆区的，只有少部分在栈区。在栈区需要我们手动 copy 到堆区
_NSConcretMallocBlock
MRC：通过copy的方法可以将block从栈区复制到堆区
ARC:大多数默认情况在堆区，有栈区的可以通过copy/strong复制到堆区，只要有一个strong指向他，就会被复制到堆区

6. 通过copy将block从栈上复制到堆上

在栈上的变量的生命周期由编译器来管理，与其作用域相关联，出了作用域就会被释放，但是堆上有程序员自己管理或者ARC管理，不会因为其出了作用域就被释放

前面提到了一个forwarding指针，用block修饰的自动变量会被保存在一个__Block_byref_a_0的结构体指针中，这个指针中又有一个指向自己的forwarding，那么为什么不直接找到其对应的值，而要通过这个指针呢，因为当block对象被从栈上赋值到堆上的时候，其内部用到的被block修饰的变量也会被赋值一份放在堆上，然后让栈上forwarding结构体指针指向堆上的结构体就可以，这样就可以保证不管在栈上还是堆上，都可以正确访问到变量

ARC 下需要不需要手动copy 的情况

当 block 被强引用时
系统的 API 中带有 usingBlock 时
block 作为函数返回值

那什么时候需要我们手动 copy 呢？

当block 作为函数参数的时候，在 arc 下我们自定义的 block 要写上 copy。

关于copy的特点

如果原来在栈上，通过copy，被复制到堆上。
如果原来在全局数据区，不会发生改变
如果在堆区：其引用计数加1

7. __block在ARC和MRC下的区别

1、用__block修饰，不管在mrc还是arc下，都可以修改自动变量的值
2、在MRC下会避免循环引用，因为mrc下用__block修饰的变量不会被reatin，所以不会被 block 持有，所以可以避免循环引用
3、在ARC下解决循环引用用的是weak：ARC下的循环引用并不是有__block引起的，是因为ARC的特性，默认是强引用，所以为了解决循环引用，self一般用weak来修饰