OC中__block的底层原理

__block本质

我们知道在block内部不能够直接修改外部的变量的值，但是我们给变量添加__block修饰后，在block内部就可以修改外部变量的值，那__block底层是怎么做到的尼？

我们新建一个工程，在main函数中添加测试代码如下：

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        
        int age = 10;
        void (^block)(void) = ^{
            age = 20;
            NSLog(@"%d", age);
        };
        
        block();
    }
    return 0;
}

这时我们编译程序，发现程序报错，编译器不通过这种写法，那么我们对main函数中的代码进行修改如下：

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        
        // 使用__block修饰
        __block int age = 10;
        void (^block)(void) = ^{
            age = 20;
            NSLog(@"%d", age); //20
        };
        
        block();
    }
    return 0;
}

我们在age变量前面添加__block修饰后，编译器就不在报错，并且可以正确修改age的值

接下来我们执行命令xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc -fobjc-arc -fobjc-runtime=ios-8.0.0 main.m将main.m文件转换为c++文件

main函数：

int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 

        // `__block int age = 10;`这句代码最终转换为__Block_byref_age_0 age = {}结构体
        __Block_byref_age_0 age = {
            0,
            // __Block_byref_age_0 age结构体自身的内存地址传递
            &age,
            0,
            sizeof(__Block_byref_age_0),
            10
        };
        
        void (*block)(void) = &__main_block_impl_0(
                                                   __main_block_func_0,
                                                   &__main_block_desc_0_DATA,
                                                   // 包装好的age结构体内存地址传递
                                                   &age,
                                                   570425344
                                                   );
        block->FuncPtr(block);
    }
    return 0;
}

block结构体：

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
    
    /**
     捕获进来的不是`Int age`变量，而是包装成`__Block_byref_age_0`类型的结构体对象。
     这个age指针一直都是强指针，强引用着__Block_byref_age_0结构体对象
     */
  __Block_byref_age_0 *age; // by ref
    
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_age_0 *_age, int flags=0) : age(_age->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

__Block_byref_age_0包装好的捕获变量的结构体：

struct __Block_byref_age_0 {
  void *__isa; // isa指针
    
    // __forwarding指针是指向自己的指针，也就是指向__Block_byref_age_0结构体
  __Block_byref_age_0 *__forwarding;
 int __flags;
 int __size;
 int age; // 这里的age才真正是block内部要修改的age变量
};

__main_block_desc_0结构体：

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_copy_0内存管理copy函数：

// 当block调用copy函数从栈上拷贝到堆上时，调用此函数
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct 
__main_block_impl_0*src) {
    
    /**
     直接产生强引用，执行retain操作，引用计数器+1
     是block对__main_block_impl_0结构体对象产生强引用
     */
    _Block_object_assign(
                         (void*)&dst->age,
                         (void*)src->age,
                         8/*BLOCK_FIELD_IS_BYREF*/
                         );
    
}

__main_block_dispose_0内存管理dispose函数：

// 当block要从堆上销毁时，调用此函数
static void __main_block_dispose_0(struct __main_block_impl_0*src) {
    
    // 当block要从堆上销毁时，就断开block对`__Block_byref_age_0 *age`的强引用，执行release操作，引用计数器-1
    _Block_object_dispose(
                          (void*)src->age,
                          8/*BLOCK_FIELD_IS_BYREF*/
                          );
    
}

__main_block_func_0block代码块函数FuncPtr：

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
    // __cself就是block结构体对象
    
    // __cself->age:取出block结构体对象中的`age`成员
  __Block_byref_age_0 *age = __cself->age; // bound by ref
    
    // age->__forwarding->age:取出__Block_byref_age_0结构体中的`int age`成员，进行赋值操作
  (age->__forwarding->age) = 20;
    
  NSLog((NSString *)&__NSConstantStringImpl__var_folders_lr_81gwkh751xzddx_ffhhb5_0m0000gn_T_main_68aaa7_mi_0, (age->__forwarding->age));
}

那么我们怎么验证在block内部修改的age就是__Block_byref_age_0结构体内部的age，而不是__main_block_impl_0结构体内部的age尼？

我们修改main.m文件的代码如下：

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

// 结构体的内存地址：0x000000010073c240，也就是结构体首成员isa的内存地址
struct __Block_byref_age_0 {
  void *__isa; // 0x000000010073c240
    
 struct __Block_byref_age_0 *__forwarding; // 0x000000010073c240 + 8 = 0x000000010073c248
 int __flags; // 0x000000010073c248 + 8 = 0x000000010073c250
 int __size; // 0x000000010073c250 + 4 = 0x000000010073c254
 int age; // 0x000000010073c254 + 4 = 0x000000010073c258
};

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

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  
  struct __Block_byref_age_0 *age; // by ref
};

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        
        __block int age = 10;
        void (^block)(void) = ^{
            age = 20;
            NSLog(@"%d", age); //20
        };
        
        // 将block变量转换为`struct __main_block_impl_0 *`类型
        struct __main_block_impl_0 *blockStruct = (__bridge struct __main_block_impl_0 *)block;
        
        
//        block();
        
        NSLog(@"%p",&age); // 0x000000010073c258
    }
    return 0;
}

我们通过断点查看blockStruct结构体对象包含的信息如图：

image

如图我们得到blockStruct -> age的内存地址为：0x000000010073c240，NSLog(@"%p",&age);打印的age变量内存地址为：0x000000010073c258

然后通过__Block_byref_age_0结构体成员的内存地址运算如下：

struct __Block_byref_age_0 {
  void *__isa; // 0x000000010073c240
    
 struct __Block_byref_age_0 *__forwarding; // 0x000000010073c240 + 8 = 0x000000010073c248
 int __flags; // 0x000000010073c248 + 8 = 0x000000010073c250
 int __size; // 0x000000010073c250 + 4 = 0x000000010073c254
 int age; // 0x000000010073c254 + 4 = 0x000000010073c258
};

由此也可知，我们在block内部修改外部的变量时，其实就是修改__Block_byref_age_0结构体内部的成员age，而不是__main_block_impl_0结构体内部的成员age

通过在控制台输入p/x &(blockStruct->age->age)打印出来的地址值也是0x000000010073c258也可以证明上面的结论

上面我们一直讲的都是使用__block修饰基本数据类型，如果使用__block修饰对象类型尼，和修饰基本数据类型有什么不同尼？

我们创建一个Person对象，然后修改main.m文件代码如下：

Person类：

@interface Person : NSObject

@end

@implementation Person

- (void)dealloc {
    NSLog(@"%s", __func__);
}
@end

main函数：

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
                
        Person *person = [[Person alloc] init];
        
        // 变量修饰符默认就是__strong
        __block __strong typeof(Person) *strongPerson = person;
        
//        __block __weak typeof(Person) *weakPerson = person;
        
        void (^block)(void) = ^{
            NSLog(@"%@", strongPerson);
        };
        
        block();
    }
    return 0;
}

然后我们执行命令xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc -fobjc-arc -fobjc-runtime=ios-8.0.0 main.m -o main2.cpp 将main.m文件转换为main2.cpp文件，代码如下：

main函数：

int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
        
        // Person *person = [[Person alloc] init];
        Person *person = ((Person *(*)(id, SEL))(void *)objc_msgSend)((id)((Person *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("Person"), sel_registerName("alloc")), sel_registerName("init"));

        // __block __strong typeof(Person) *strongPerson = person;
        __Block_byref_strongPerson_0 strongPerson = {
            0,
            &strongPerson,
            33554432,
            sizeof(__Block_byref_strongPerson_0),
            __Block_byref_id_object_copy_131,
            __Block_byref_id_object_dispose_131,
            person
        };

        void (*block)(void) = &__main_block_impl_0(
                                                   __main_block_func_0,
                                                   &__main_block_desc_0_DATA,
                                                   &strongPerson,
                                                   570425344
                                                   );
        block->FuncPtr(block);
    }
    return 0;
}

block结构体：

sstruct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
    
    // 这个指针一直是强指针
  __Block_byref_strongPerson_0 *strongPerson; // by ref
    
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_strongPerson_0 *_strongPerson, int flags=0) : strongPerson(_strongPerson->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

__Block_byref_strongPerson_0结构体：

struct __Block_byref_strongPerson_0 {
  void *__isa; // 8
 __Block_byref_strongPerson_0 *__forwarding; // 8
 int __flags; // 4
 int __size; // 4
    
    // 在__block修饰变量新增的结构体内，新增了两个内存管理函数
    
    // __Block_byref_id_object_copy_131
 void (*__Block_byref_id_object_copy)(void*, void*); // 8
    
    // __Block_byref_id_object_dispose_131
 void (*__Block_byref_id_object_dispose)(void*); // 8
    
    // 这个指针有强弱之分，是强指针还是弱指针取决于修饰符是__strong还是__weak
    // 当前是strongPerson是强指针，强引用着block外面创建的`person`对象
    Person *__strong strongPerson;
};

__main_block_copy_0block的copy函数：

// block的内存管理函数，当block执行copy从栈拷贝到堆上时，调用此函数
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {
    /**
     当block拷贝到堆上时，它也会将`struct __Block_byref_strongPerson_0`这个结构体从栈上拷贝到堆上，
     这个结构体内部也有自己的内存管理，因为`__Block_byref_strongPerson_0`结构体内部的`Person *__strong strongPerson`指针会引用着block外部的Person对象
     
     注意：当调用_Block_object_assign函数，函数内部会调用`__Block_byref_id_object_copy_131`函数
     */
    _Block_object_assign(
                         (void*)&dst->strongPerson,
                         (void*)src->strongPerson,
                         8/*BLOCK_FIELD_IS_BYREF*/
                         );
    
}

__main_block_dispose_0block的dispose函数

// block的内存管理函数，当block需要从堆上销毁时，调用此函数
static void __main_block_dispose_0(struct __main_block_impl_0*src) {
    /**
     block从堆上销毁时，就断开对`__Block_byref_strongPerson_0`结构体的强引用，执行release操作，引用计数器-1
     
     注意：当调动_Block_object_dispose函数，函数内部会调用`__Block_byref_id_object_dispose_131`函数
     */
    _Block_object_dispose(
                          (void*)src->strongPerson,
                          8/*BLOCK_FIELD_IS_BYREF*/
                          );
}

__Block_byref_id_object_copy_131:__Block_byref_strongPerson_0结构体的copy函数

// __Block_byref_strongPerson_0结构体的内存管理函数 copy
static void __Block_byref_id_object_copy_131(void *dst, void *src) {
    /**
     这里的`dst`指针指向的地址值就是`__Block_byref_strongPerson_0`结构体的地址值
     `dst`的地址值 + 40个字节，对应的正好是`__Block_byref_strongPerson_0`结构体内的`Person *__strong strongPerson;`成员
     
     也就是说_Block_object_assign()函数会根据传递的`person`参数是强指针还是弱指针进行内存管理操作
     */
 _Block_object_assign(
                      (char*)dst + 40,
                      *(void * *) ((char*)src + 40),
                      131);
}

__Block_byref_id_object_dispose_131:__Block_byref_strongPerson_0结构体的dispose函数

// __Block_byref_strongPerson_0结构体的内存管理函数 dispose
static void __Block_byref_id_object_dispose_131(void *src) {
 _Block_object_dispose(
                       *(void * *) ((char*)src + 40),
                       131);
}

__main_block_func_0block代码块FuncPtr：

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
    // 取出block结构体内的`__Block_byref_strongPerson_0`对象：__cself->strongPerson
  __Block_byref_strongPerson_0 *strongPerson = __cself->strongPerson; // bound by ref
  NSLog((NSString *)&__NSConstantStringImpl__var_folders_lr_81gwkh751xzddx_ffhhb5_0m0000gn_T_main_721406_mi_0, (strongPerson->__forwarding->strongPerson));
}

__block底层数据结构图解如下：

image

image

__block修饰对象类型内存管理图解如下：

image
image

__block修饰对象生成结构体中的__forwarding指针用法图解：

image

__block修饰对象类型底层用法图解：

image

__block修饰对象类型变量，并且使用__strong修饰，代码如下：

     Person *person = [[Person alloc] init];

    // 对象属性不写默认就是__strong修饰
    __block __strong typeof(Person) *strongPerson = person;
    
    void (^block)(void) = ^{
        NSLog(@"%@", strongPerson);
    };

    block();

block引用关系如图：

image

__block修饰对象类型变量，并且使用__weak修饰，代码如下：

     Person *person = [[Person alloc] init];

    __block __weak typeof(Person) *weakPerson = person;

    void (^block)(void) = ^{
        NSLog(@"%@", weakPerson);
    };

    block();

block引用关系如图：

image

讲解示例代码Demo地址：https://github.com/guangqiang-liu/06.5-__blockDemo

更多文章

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 159,290评论 4赞 363
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 67,399评论 1赞 294
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 109,021评论 0赞 243
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 44,034评论 0赞 207
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 52,412评论 3赞 287
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 40,651评论 1赞 219
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 31,902评论 2赞 313
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 30,605评论 0赞 199
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 34,339评论 1赞 246
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 30,586评论 2赞 246
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 32,076评论 1赞 261
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 28,400评论 2赞 253
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 33,060评论 3赞 236
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 26,083评论 0赞 8
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 26,851评论 0赞 195
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 35,685评论 2赞 274
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 35,595评论 2赞 270