探究block本质

记录一下，分六个方面来探究block，一步步分析。

一.block底层结构
写一个最简单的block：

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        void (^block)(void) = ^{
            
        };
        block();
    }
    return 0;
}

c++重写：xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m -o main-arm64.cpp
删减了一部分非必要代码，发现对应c++结构：

int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
        void (*block)(void) = __main_block_impl_0(__main_block_func_0,__main_block_desc_0_DATA);
        ((block)->FuncPtr)(block);
    }
    return 0;
}

void (*block)(void) =__main_block_impl_0(__main_block_func_0,__main_block_desc_0_DATA); :block 定义

((block)->FuncPtr)(block);：调用block

找到__main_block_impl_0

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

结构体中有一个__main_block_impl_0构造函数，不同于oc，主要作用就是给结构体中的impl 和 Desc 赋值。

__main_block_impl_0的参数：
fp：函数指针
desc：结构体描述
flags：标志,默认是0

接下来我们找到传入的参数：
__main_block_func_0 和 __main_block_desc_0_DATA。
__main_block_func_0结构如下：

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
}

就是一个函数。
__main_block_desc_0_DATA 结构如下：

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

__main_block_desc_0_DATA 是 struct __main_block_desc_0 的一个结构体类型的变量

struct __main_block_desc_0:
reserved：保留字
Block_size：block 的大小

__main_block_desc_0_DATA 结构体大小是 sizeof(struct __main_block_impl_0)

struct __main_block_impl_0结构如下：

struct __main_block_impl_0 {
    struct __block_impl impl;
    struct __main_block_desc_0* Desc;
};

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

isa：说明block 是个对象，对象才有isa指针
FuncPtr：函数指针
所以一个block 大小是由struct __block_impl 结构体大小 + __main_block_desc_0*指针（8字节）。

讲到这是不是有些蒙了，没关系，本身block 就比较复杂。
阶段总结：

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

struct __main_block_desc_0 {
    size_t reserved;
    size_t Block_size;
};


struct __main_block_impl_0 {
    struct __block_impl impl;
    struct __main_block_desc_0* Desc;
};

__main_block_impl_0:block结构
__main_block_impl_0 的两个结构体成员：

struct __block_impl impl ：

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

2.__main_block_desc_0* Desc：

struct __main_block_desc_0 {
    size_t reserved;
    size_t Block_size;
};

__main_block_impl_0：构造函数，用来给impl和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;
}

4.((block)->FuncPtr)(block);：调用block,参数是block本身，对应函数如下：

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {}

image.png

在脑子里记忆一下各个结构。

二.捕获变量
上面主要是讲了block最基本的结构，但是我们平时用的block 不会那么简单，会引用外部的一些变量。
1.变量有三种：
自动变量、全局变量、static 变量
2.看看如何捕获变量

1）自动变量:

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

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_dc_k7v9mmb518nfz45rg4zgnk0c0000gn_T_main_3cbf15_mi_0,a);
}

发现auto变量被捕获到了block结构体里,且是值传递

2）static 变量：

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

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_dc_k7v9mmb518nfz45rg4zgnk0c0000gn_T_main_3ae54e_mi_0,(*a));    
}

发现捕获到block 结构体里，且是地址传递

3）全局变量

int a = 0;

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

int a = 0;

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_dc_k7v9mmb518nfz45rg4zgnk0c0000gn_T_main_d9d28e_mi_0,a);
}

发现没有捕获变量，且全局直接访问。

阶段总结：

image.png

捕获：
1）常量，auto变量，static 变量都会被捕获到block内部
2）全局变量不会被捕获到block 内部（因为跨函数的）

访问方式：
1）常量，基本数据类型int ，通过值传递的方式
2）static 变量，对象类型变量，通过指针方式
3）全局变量，直接访问

思考：self 和 _name 会不会被捕获？

三.block类型
既然block 是个对象，那么block 的isa 指向的是类对象，类对象的isa 指针指向元类对象。

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        int a = 0;
        void (^block)(void) = ^{
            NSLog(@"%d",a);
        };
        block();
        
        
        NSLog(@"类对象：%@",object_getClass(block));
        NSLog(@"元类对象：%@",object_getClass(object_getClass(block)));
        
        NSLog(@"类：%@",[block class]);
        NSLog(@"类：%@",[block superclass]);
        NSLog(@"类：%@",[[block superclass] superclass]);
        NSLog(@"类：%@",[[[block superclass] superclass] superclass]);


    }
    return 0;
}

2018-08-28 16:28:32.232074+0800 block[3328:141892] 类对象：__NSMallocBlock__
2018-08-28 16:28:32.232117+0800 block[3328:141892] 元类对象：__NSMallocBlock__

2018-08-28 16:28:32.232150+0800 block[3328:141892] 类：__NSMallocBlock__
2018-08-28 16:28:32.232194+0800 block[3328:141892] 类：__NSMallocBlock
2018-08-28 16:28:32.232215+0800 block[3328:141892] 类：NSBlock
2018-08-28 16:28:32.232231+0800 block[3328:141892] 类：NSObject

block 有三种类型：
NSMallocBlock、NSGlobalBlock、NSStackBlock
分别对应堆区、全局区、栈区

AD3971E2-2589-43B1-B5BC-EB7EF0D447FD.png

MRC:
代码就不具体写了，直接给出结论

image.png

image.png

MRC下 NSStackBlock 通过copy 拷贝到堆上，这也是为什么在MRC 时代，block 属性都是copy策略而且这种写法延续至ARC 时代。

ARC:

NSStackBlock

int a = 0;
NSLog(@"%@",^{a;});

访问自动变量，且没有强指针引用，那么该block 会在栈上

NSMallocBlock

int a = 0;
void (^block)(void) = ^{
      NSLog(@"%d",a);
};
block();

访问自动变量，且有强指针引用，那么该block 会被copy在堆上

NSGlobalBlock

int a = 0;

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

访问变量在全局区，block在全局区

在ARC环境下，编译器会根据情况自动将栈上的block拷贝到堆上，情况如下：
1）block 赋值给强类型指针
2）block 作为返回值
3）Cocoa API 中含有usingBlock的方法参数（比如enumerateObjectsUsingBlock）
4）GCD API

四.copy和dispose

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

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

static void __main_block_dispose_0(struct __main_block_impl_0*src) {
    _Block_object_dispose((void*)src->obj, 3/*BLOCK_FIELD_IS_OBJECT*/);
}

访问常量类型：不会有copy、dispose函数
访问对象类型：全局变量没有copy、dispose函数;auto,static是有copy、dispose函数

没有：全局、基本数据类型。没有
有：非全局对象类型（对象，变量static ..修饰）、__block 修饰的变量
本质看是否有copy dispose,主要是对象需不需要内存管理。

当block 内部访问对象类型的auto 变量时：
·如果block在栈上，不会对auto 变量产生强引用
·block从栈拷贝到堆上时，会调用copy 函数
·堆上的block 被移除时，会调用dispose 函数

四.__weak __strong

__weak

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

2018-08-29 17:39:44.431257+0800 block[6386:159222] Person+dealloc
2018-08-29 17:39:44.431530+0800 block[6386:159222] (null)
2018-08-29 17:39:44.431770+0800 block[6386:159222] <__NSMallocBlock__: 0x1007000a0>

c++ 重写:
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc -fobjc-arc -fobjc-runtime=ios-8.0.0 main.m -o main-arm64.cpp

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  Person *__weak weakObj;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, Person *__weak _weakObj, int flags=0) : weakObj(_weakObj) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

对于 __weak 变量，block 对变量是弱引用，而且通过打印可以知道。

__strong

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

2018-08-29 17:45:45.177167+0800 block[6450:162386] 
2018-08-29 17:45:45.177414+0800 block[6450:162386] <__NSMallocBlock__: 0x10056e0d0>
2018-08-29 17:45:45.177434+0800 block[6450:162386] Person+dealloc

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  Person *strongObj;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, Person *_strongObj, int flags=0) : strongObj(_strongObj) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

对于 __strong 变量，block 对变量是强引用,在block 调用之后释放对象。
对于__strong，分外部捕获变量和内部使用__strong。
对于外部捕获变量，在block 调用之后释放对象，在定义的时候会影响对象的引用计数。
对于内部使用__strong，在调用block时候会强引用对象，执行完毕对象引用计数会-1。

五.__block
1.比较重点的一个关键字。我们还是通过程序来深入：
首先抛出一个问题，block内什么类型的变量是可以直接修改的？什么类型的变量需要通过__block修饰来修改？

image.png

image.png

image.png

上面3个例子说明了什么？
回顾之前说的问题，关于变量捕获。很容易发现：
1）指针传值和直接访问的变量可以直接修改
2）而对于值传递的变量不能直接修改

对于值传递的变量，需要用到__block关键字

image.png

2.c++ 重写：

int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
        __attribute__ __Block_byref_a_0 a = {(void*)0,(__Block_byref_a_0 *)&a, 0, sizeof(__Block_byref_a_0), 0};
        Block block = (&__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA, &a, 570425344));
        ((block)->FuncPtr)(block);
        NSLog((NSString *)&__NSConstantStringImpl__var_folders_dc_k7v9mmb518nfz45rg4zgnk0c0000gn_T_main_f3bf08_mi_1,(a.__forwarding->a));
    }
    return 0;
}

在编译的时候，就将int a包装成了一个__Block_byref_a_0结构体

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

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __Block_byref_a_0 *a; // by ref
  __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;
  }
};

image.png

__isa：isa 指针
__forwarding：指向本身的指针
__flags：标志
__size：大小
a：变量

image.png

4.看看如何修改的变量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) = 10;
    NSLog((NSString *)&__NSConstantStringImpl__var_folders_dc_k7v9mmb518nfz45rg4zgnk0c0000gn_T_main_f3bf08_mi_0,(a->__forwarding->a));
}

看代码，发现是通过本身__forwarding指针来修改的变量。
为什么需要通过__forwarding？

image.png

如图，因为栈上的__block 结构体的__forwarding会指向堆上的__block 结构体，这样无论是修改的栈上的变量还是修改的堆上的变量，本质都是修改的堆上的变量。

我们来验证一下：

对于变量a

typedef void(^Block)(void);


struct __block_impl {
    void *isa;//isa
    int Flags;
    int Reserved;//保留字段
    void *FuncPtr;//函数指针
};

struct __main_block_desc_0 {
    size_t reserved;
    size_t Block_size;
};

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

struct __main_block_impl_0 {
    struct __block_impl impl;
    struct __main_block_desc_0* Desc;
    struct __Block_byref_a_0 *a; // by ref
};

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        __block int a = 0;
        NSLog(@"1：%p",&a);
        Block block = ^{
            a = 10;
            NSLog(@"2：%p",&a);
        };
        block();
        struct __main_block_impl_0 *__main_block_impl_0 = (__bridge struct __main_block_impl_0*)block;
        NSLog(@"4：%p",&(__main_block_impl_0->a->a));
    }
    return 0;
}

结果：

2018-08-29 18:56:44.827148+0800 block[7802:203927] 1：0x7ffeefbff5d8
2018-08-29 18:56:44.827382+0800 block[7802:203927] 2：0x10076dc88
2018-08-29 18:56:44.827399+0800 block[7802:203927] 4：0x10076dc88

发现结构体中a的地址 和 block 内部的a 的地址相同,并且苹果block 内部的a 的地址返回，而不是返回block 内部的a 结构体地址。

对于__forwarding指针：

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        __block int a = 0;
        Block block = ^{
            a = 10;
        };
        block();
        struct __main_block_impl_0 *__main_block_impl_0 = (__bridge struct __main_block_impl_0*)block;
        NSLog(@"1：%p",(__main_block_impl_0->a));
        NSLog(@"2：%p",(__main_block_impl_0->a->__forwarding));
    }
    return 0;
}

结果：

2018-08-29 19:02:27.973656+0800 block[7884:207149] 1：0x10061fc20
2018-08-29 19:02:27.973822+0800 block[7884:207149] 2：0x10061fc20

堆中__block 结构体的__forwarding会指向本身

block 在栈上，不会对 __block 变量产生强引用
block 在堆上，会对__block 变量产生强引用

六.ARC下block 循环引用

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

并没有打印dealloc,发现person 对象并没有释放。
1）block 在堆上
2）堆上的block 是对person 强引用
3）person 强引用block
4）造成循环引用

image.png

block 会强引用 person 对象，block 释放，person 才会释放。person 强引用block ，person 释放，block 才会释放。由此，造成了循环引用的问题。

打破循环引用很简单：
1）断开block 对 person 的强引用
2）断开person 对 block 的强引用

一般来说，实例一定会强引用block，因为要保证person 生命周期内，属性是存在的。所以我们一般会断开block 对实例的强引用

2.破循环引用的方法

1)一般我们会用__weak 指针指向实例

image.png

2)__block 修饰实例，执行block，将person 置nil ,打破循环

image.png

由此！block基本点已经讲完了，感觉block还是很复杂的，后续内容会持续更新！

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

//位运算，得到方法签名默认都是有签名的
enum {
BLOCK_HAS_COPY_DISPOSE = (1 << 25), //是否有copy函数
BLOCK_HAS_CTOR = (1 << 26), // helpers have C++ code
BLOCK_IS_GLOBAL = (1 << 28),
BLOCK_HAS_STRET = (1 << 29), // IFF BLOCK_HAS_SIGNATURE
BLOCK_HAS_SIGNATURE = (1 << 30), //是否有block方法签名
};

Flags 的作用是判断是否有copy函数，是否有block方法签名等等

hookBlock:
https://github.com/GreyLove/HookBlock

探究block本质

你可能感兴趣的:(探究block本质)