iOS-Block源码分析

Jieyi

图片描述

古巷悠悠岁月深,青石老街印旧痕
今夜小楼听风雨,不见当年伞下人

前言

Block作为iOS中老生常谈的问题,也是面试中面试官比较喜欢问的 一个问题 ,下面我们通过源码查看block的底层实现原理

什么是Block

Block:将函数及其上下文组装起来的对象

Block本质就是一个对象

创建一个PHJBlock类

    @implementation PHJBlock
    
    - (void)test {
        int a = 10;
        void (^ block)(void) = ^{
            NSLog(@"%d", a);
        };
        block();
    }
    
    @end

查看编译后的C++源码

编译: Clang -rewrite-objc PHJBlock.m

    static void _I_PHJBlock_test(PHJBlock * self, SEL _cmd) {
        int a = 10;
        void (* block)(void) = ((void (*)())&__PHJBlock__test_block_impl_0((void *)__PHJBlock__test_block_func_0, &__PHJBlock__test_block_desc_0_DATA, a));
        ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
    }   
    

__PHJBlock__test_block_impl_0的内部实现

     struct __PHJBlock__test_block_impl_0 {
          struct __block_impl impl;
          struct __PHJBlock__test_block_desc_0* Desc;
          int a;
          __PHJBlock__test_block_impl_0(void *fp, struct __PHJBlock__test_block_desc_0 *desc, int _a, int flags=0) : a(_a) {
            impl.isa = &_NSConcreteStackBlock;
            impl.Flags = flags;
            impl.FuncPtr = fp;
            Desc = desc;
          }
        };

__block_impl的内部实现

看到isa,证明block的本质就是一个对象

    struct __block_impl {
      void *isa; // 看到isa,证明block的本质就是一个对象
      int Flags;
      int Reserved;
      void *FuncPtr;
    };

Block的三种类型

栈Block
堆Block
全局Block

        int a = 10;
        // 堆block
        void(^block)(void) = ^{
            NSLog(@"%d", a);
        };
        block();
        NSLog(@"%@", block);
        
        // 全局block
        void(^block1)(void) = ^{
        };
        block1();
        NSLog(@"%@", block1);
        
        // 栈block
        NSLog(@"%@", ^{
            NSLog(@"%d", a);
        });

打印查看block内存地址
图片描述

Block捕获外部变量

局部变量

基本数据类型:截获其值
对象类型:对于对象类型的局部变量连同所有权修饰符一起截获

静态局部变量

以指针形式

全局变量

不截获

静态全局变量

不截获

Block捕获基本数据类型局部变量

不加修饰词修饰的变量

    - (void)test {
        int a = 100;
        void(^block)(void) = ^{
            printf("%d", a);
        };
        block();
    }

编译后的C++代码:捕获外部变量的值

    static void __PHJBlock__test_block_func_0(struct __PHJBlock__test_block_impl_0 *__cself) {
      // 捕获 a 的值
      int a = __cself->a; // bound by copy
            printf("%d", a);
        }
    

加修饰词修饰的变量

    - (void)test {
        __block int a = 100;
        void(^block)(void) = ^{
            a ++;
            printf("%d", a);
        };
        block();
    }

编译后的C++代码:捕获外部变量的的地址

总结:这也就解释了为什么我们在外部变量前加上__block就能在block内部可以修改变量的值

    static void __PHJBlock__test_block_func_0(struct __PHJBlock__test_block_impl_0 *__cself) {
      // 捕获 a 的地址
      __Block_byref_a_0 *a = __cself->a; // bound by ref
    
            (a->__forwarding->a) ++;
            printf("%d", (a->__forwarding->a));
    }

发现变量a加上__block后变成了一个对象
__forwarding指针

    struct __Block_byref_a_0 {
      void *__isa;
    __Block_byref_a_0 *__forwarding;
     int __flags;
     int __size;
     int a;
    };

Block捕获对象类型局部变量

    - (void)test {
        
        __unsafe_unretained id obj = nil;
        __strong NSObject *obj1 = nil;
        
        void(^block)(void) = ^{
            NSLog(@"__unsafe_unretained类型变量:%@", obj);
            
            NSLog(@"__strong类型变量:%@", obj1);
        };
        block();
    }

编译后的C++代码:连同外部变量的修饰词一起捕获

    static void _I_PHJBlock_test(PHJBlock * self, SEL _cmd) {
    
        // 修饰词一起捕获
        __attribute__((objc_ownership(none))) id obj = __null;
        __attribute__((objc_ownership(strong))) NSObject *obj1 = __null;
    
        void(*block)(void) = ((void (*)())&__PHJBlock__test_block_impl_0((void *)__PHJBlock__test_block_func_0, &__PHJBlock__test_block_desc_0_DATA, obj, obj1, 570425344));
        ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
    }

总结:这也就解释了为什么我们在外部对象前加上__weak就能在block内部使用的时候可以避免循环引用问题

Block捕获静态局部变量

    - (void)test {
        static int a = 100;
        void(^block)(void) = ^{
            NSLog(@"static类型变量a :%d", a);
        };
        block();
    }

编译后的C++代码:捕获变量的地址

&a代表传入的是a变量的地址

    static void _I_PHJBlock_test(PHJBlock * self, SEL _cmd) {
        static int a = 100;
        // 下面的&a代表传入的是a变量的地址
        void(*block)(void) = ((void (*)())&__PHJBlock__test_block_impl_0((void *)__PHJBlock__test_block_func_0, &__PHJBlock__test_block_desc_0_DATA, &a));
        ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
    }

int *a接收传入的a变量的地址

    struct __PHJBlock__test_block_impl_0 {
      struct __block_impl impl;
      struct __PHJBlock__test_block_desc_0* Desc;
      // 捕获a变量的地址
      int *a;
      __PHJBlock__test_block_impl_0(void *fp, struct __PHJBlock__test_block_desc_0 *desc, int *_a, int flags=0) : a(_a) {
        impl.isa = &_NSConcreteStackBlock;
        impl.Flags = flags;
        impl.FuncPtr = fp;
        Desc = desc;
      }
    };

Block不会捕获全局变量

    int a = 100;
    
    @implementation PHJBlock
    
    - (void)test {
        void(^block)(void) = ^{
            NSLog(@"全局变量a :%d", a);
        };
        block();
    }
    
    @end

编译后的C++代码:不会捕获全局变量

    struct __PHJBlock__test_block_impl_0 {
      struct __block_impl impl;
      struct __PHJBlock__test_block_desc_0* Desc;
      __PHJBlock__test_block_impl_0(void *fp, struct __PHJBlock__test_block_desc_0 *desc, int flags=0) {
        impl.isa = &_NSConcreteStackBlock;
        impl.Flags = flags;
        impl.FuncPtr = fp;
        Desc = desc;
      }
    };

Block不会捕获静态全局变量

    static int a = 100;
    
    @implementation PHJBlock
    
    - (void)test {
        void(^block)(void) = ^{
            NSLog(@"全局变量a :%d", a);
        };
        block();
    }
    
    @end

编译后的C++代码:不会捕获静态全局变量

    struct __PHJBlock__test_block_impl_0 {
      struct __block_impl impl;
      struct __PHJBlock__test_block_desc_0* Desc;
      __PHJBlock__test_block_impl_0(void *fp, struct __PHJBlock__test_block_desc_0 *desc, int flags=0) {
        impl.isa = &_NSConcreteStackBlock;
        impl.Flags = flags;
        impl.FuncPtr = fp;
        Desc = desc;
      }
    };

一般情况下对截获变量进行赋值操作需要加__block

需要加__block

    __block NSMutableDictionary *dicM = nil;
    void(^block)(void) = ^{
       dicM = [NSMutableDictionary dictionary];
    };
    block();

不需要加__block

    NSMutableDictionary *dicM = nil;
    void(^block)(void) = ^{
       [dicM setObject:@(1) forKey:@"1"];
    };
    block();

总结:赋值的时候需要加__block,操作使用的时候不用加

__forwarding指针

栈Block没有进行copy操作

 栈__forwarding指针都指向栈中自己的变量

栈Block如果进行了copy操作

栈和堆上的__forwarding指针都指向堆的变量

总结:不论在任何内存位置,都可以顺利访问同一个__block变量

Block的Copy操作

栈block进行copy,得到堆block
堆block进行copy,增加引用计数
全局block进行copy,block不会产生影响

__block 修饰局部对象类型变量的循环引用问题

MRC下,不会产生循环引用
在ARC下,会产生循环引用,引起内存泄漏,解决:在block内部对__block修饰的对象变量进行置nil操作

阅读 2.5k

民德新民 止于至善

102 声望
8 粉丝
0 条评论

民德新民 止于至善

102 声望
8 粉丝
文章目录
宣传栏