iOS中block介绍（四）揭开神秘面纱(下)

最新推荐文章于 2021-11-26 17:29:22 发布
最新推荐文章于 2021-11-26 17:29:22 发布
阅读量457 收藏
点赞数
本文深入解析Block的内存管理机制，通过分析runtime库源码揭示不同内存区Block的区别及复制过程。详细介绍了栈Block、全局Block和堆Block的isa指针赋值规则，并探讨了辅助copy/dispose函数的作用。
摘要由CSDN通过智能技术生成

终于有空开始这系列最后一篇的编写。这一篇，我们将看到block的内存管理的内部实现，通过剖析runtime库源码，我们可以更深刻的理解block的内存运作体系。

AD：51CTO 网+ 第十二期沙龙：大话数据之美_如何用数据驱动用户体验

看此篇时，请大家同时打开两个网址（或者下载它们到本地然后打开）：

http://llvm.org/svn/llvm-project/compiler-rt/trunk/BlocksRuntime/runtime.c

http://llvm.org/svn/llvm-project/compiler-rt/trunk/BlocksRuntime/Block_private.h

内存管理的真面目

objc层面如何区分不同内存区的block

Block_private.h中有这样一组值：

   
   
  1. /* the raw data space for runtime classes for blocks */ 
  2. /* class+meta used for stack, malloc, and collectable based blocks */ 
  3. BLOCK_EXPORT void * _NSConcreteStackBlock[32]; 
  4. BLOCK_EXPORT void * _NSConcreteMallocBlock[32]; 
  5. BLOCK_EXPORT void * _NSConcreteAutoBlock[32]; 
  6. BLOCK_EXPORT void * _NSConcreteFinalizingBlock[32]; 
  7. BLOCK_EXPORT void * _NSConcreteGlobalBlock[32]; 
  8. BLOCK_EXPORT void * _NSConcreteWeakBlockVariable[32]; 

其用于对block的isa指针赋值

1.栈

   
   
  1. struct __OBJ1__of2_block_impl_0 { 
  2.   struct __block_impl impl; 
  3.   struct __OBJ1__of2_block_desc_0* Desc; 
  4.   OBJ1 *self; 
  5.   __OBJ1__of2_block_impl_0(void *fp, struct __OBJ1__of2_block_desc_0 *desc, OBJ1 *_self, int flags=0) : self(_self) { 
  6.     impl.isa = &_NSConcreteStackBlock; 
  7.     impl.Flags = flags; 
  8.     impl.FuncPtr = fp; 
  9.     Desc = desc; 
  10.   } 
  11. }; 

在栈上创建的block，其isa指针是_NSConcreteStackBlock。

2.全局区

在全局区创建的block，其比较类似，其构造函数会将isa指针赋值为_NSConcreteGlobalBlock。

3.堆

我们无法直接创建堆上的block，堆上的block需要从stack block拷贝得来，在runtime.c中的_Block_copy_internal函数中，有这样几行：

   
   
  1. // Its a stack block.  Make a copy. 
  2.     if (!isGC) { 
  3.         struct Block_layout *result = malloc(aBlock->descriptor->size); 
  4.         ... 
  5.         result->isa = _NSConcreteMallocBlock; 
  6.         ... 
  7.         return result; 
  8.     } 

可以看到，栈block复制得来的新block，其isa指针会被赋值为_NSConcreteMallocBlock

4.其余的isa类型

   
   
  1. BLOCK_EXPORT void * _NSConcreteAutoBlock[32]; 
  2. BLOCK_EXPORT void * _NSConcreteFinalizingBlock[32]; 
  3. BLOCK_EXPORT void * _NSConcreteWeakBlockVariable[32]; 

其他三种类型是用于gc和arc，我们暂不讨论

复制block

对block调用Block_copy方法，或者向其发送objc copy消息，最终都会调用runtime.c中的_Block_copy_internal函数，其内部实现会检查block的flag，从而进行不同的操作：

   
   
  1. static void *_Block_copy_internal(const void *arg, const int flags) { 
  2.     ... 
  3.     aBlock = (struct Block_layout *)arg; 
  4.     ... 
  5. }1.栈block的复制 
  6.  
  7.         // reset refcount 
  8.         result->flags &= ~(BLOCK_REFCOUNT_MASK);    // XXX not needed 
  9.         result->flags |= BLOCK_NEEDS_FREE | 1; 
  10.         result->isa = _NSConcreteMallocBlock; 
  11.         if (result->flags & BLOCK_HAS_COPY_DISPOSE) { 
  12.             //printf("calling block copy helper %p(%p, %p)...\n", aBlock->descriptor->copy, result, aBlock); 
  13.             (*aBlock->descriptor->copy)(result, aBlock); // do fixup 
  14.         } 

除了修改isa指针的值之外，拷贝过程中，还会将BLOCK_NEEDS_FREE置入，大家记住这个值，后面会用到。

最后，如果block有辅助copy/dispose函数，那么辅助的copy函数会被调用。

2.全局block的复制

   
   
  1. else if (aBlock->flags & BLOCK_IS_GLOBAL) { 
  2.         return aBlock; 
  3.     }全局block进行copy是直接返回了原block，没有任何的其他操作。

全局block进行copy是直接返回了原block，没有任何的其他操作。

3.堆block的复制

   
   
  1. if (aBlock->flags & BLOCK_NEEDS_FREE) { 
  2.     // latches on high 
  3.     latching_incr_int(&aBlock->flags); 
  4.     return aBlock; 
  5. } 

栈block复制时，置入的BLOCK_NEEDS_FREE标记此时起作用，_Block_copy_internal函数识别当前block是一个堆block，则仅仅增加引用计数，然后返回原block。

辅助copy/dispose函数

1.普通变量的复制

辅助copy函数用于拷贝block所引用的可修改变量，我们这里以 __block int i = 1024为例：

先看看Block_private.h中的定义：

   
   
  1. struct Block_byref { 
  2.     void *isa; 
  3.     struct Block_byref *forwarding; 
  4.     int flags; /* refcount; */ 
  5.     int size; 
  6.     void (*byref_keep)(struct Block_byref *dst, struct Block_byref *src); 
  7.     void (*byref_destroy)(struct Block_byref *); 
  8.     /* long shared[0]; */ 
  9. }; 

而我们的__block int i = 1024的转码：

   
   
  1. struct __Block_byref_i_0 { 
  2.   void *__isa; 
  3. __Block_byref_i_0 *__forwarding; 
  4.  int __flags; 
  5.  int __size; 
  6.  int i; 
  7. };//所以我们知道，当此结构体被类型强转为Block_byref时，前四个成员是一致的，访问flags就相当于访问__flags，而内部实现就是这样使用的 
  8. ... 
  9. __attribute__((__blocks__(byref))) __Block_byref_i_0 i = {(void*)0,(__Block_byref_i_0 *)&i, 0, sizeof(__Block_byref_i_0), 1024};//i初始化时__flags为0static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->i, (void*)src->i, 8/*BLOCK_FIELD_IS_BYREF*/);} 

此时，复制时调用的辅助函数：

   
   
  1. void _Block_object_assign(void *destAddr, const void *object, const int flags) {//此处flags为8，即BLOCK_FIELD_IS_BYREF 
  2.     ... 
  3.     if ((flags & BLOCK_FIELD_IS_BYREF) == BLOCK_FIELD_IS_BYREF)  { 
  4.         // copying a __block reference from the stack Block to the heap 
  5.         // flags will indicate if it holds a __weak reference and needs a special isa 
  6.         _Block_byref_assign_copy(destAddr, object, flags); 
  7.     } 
  8.     ... 
  9. } 
  10.  
  11. static void _Block_byref_assign_copy(void *dest, const void *arg, const int flags) {//此处flags为8，即BLOCK_FIELD_IS_BYREF 
  12.     struct Block_byref **destp = (struct Block_byref **)dest; 
  13.     struct Block_byref *src = (struct Block_byref *)arg; 
  14.     ... 
  15.     else if ((src->forwarding->flags & BLOCK_REFCOUNT_MASK) == 0) {//当初次拷贝i时，flags为0，进入此分支会进行复制操作并改变flags值，置入BLOCK_NEEDS_FREE和初始的引用计数 
  16.        ... 
  17.     } 
  18.     // already copied to heap 
  19.     else if ((src->forwarding->flags & BLOCK_NEEDS_FREE) == BLOCK_NEEDS_FREE) {//当再次拷贝i时，则仅仅增加其引用计数 
  20.         latching_incr_int(&src->forwarding->flags); 
  21.     } 
  22.     // assign byref data block pointer into new Block 
  23.     _Block_assign(src->forwarding, (void **)destp);//这句仅仅是直接赋值，其函数实现只有一行赋值语句，查阅runtime.c可知 
  24. } 

所以，我们知道，当我们多次copy一个block时，其引用的__block变量只会被拷贝一次。

2.objc变量的复制 

当objc变量没有__block修饰时：

   
   
  1. static void __OBJ1__of2_block_copy_0(struct __OBJ1__of2_block_impl_0*dst, struct __OBJ1__of2_block_impl_0*src) {_Block_object_assign((void*)&dst->self, (void*)src->self, 3/*BLOCK_FIELD_IS_OBJECT*/);}void _Block_object_assign(void *destAddr, const void *object, const int flags) { 
  2.     ... 
  3.     else if ((flags & BLOCK_FIELD_IS_OBJECT) == BLOCK_FIELD_IS_OBJECT) { 
  4.         //printf("retaining object at %p\n", object); 
  5.         _Block_retain_object(object);//当我们没有开启arc时，这个函数会retian此object 
  6.         //printf("done retaining object at %p\n", object); 
  7.         _Block_assign((void *)object, destAddr); 
  8.     } 
  9.     .... 
  10. } 

当objc变量有__block修饰时：

   
   
  1. struct __Block_byref_bSelf_0 { 
  2.   void *__isa; 
  3. __Block_byref_bSelf_0 *__forwarding; 
  4.  int __flags; 
  5.  int __size; 
  6.  void (*__Block_byref_id_object_copy)(void*, void*); 
  7.  void (*__Block_byref_id_object_dispose)(void*); 
  8.  OBJ1 *bSelf; 
  9. }; 
  10. static void __Block_byref_id_object_copy_131(void *dst, void *src) { 
  11.  _Block_object_assign((char*)dst + 40, *(void * *) ((char*)src + 40), 131);//131即为BLOCK_FIELD_IS_OBJECT|BLOCK_BYREF_CALLER 
  12. } 
  13. static void __Block_byref_id_object_dispose_131(void *src) { 
  14.  _Block_object_dispose(*(void * *) ((char*)src + 40), 131); 
  15. } 
  16.   
  17. ... //33554432即为BLOCK_HAS_COPY_DISPOSE 
  18.     __block __Block_byref_bSelf_0 bSelf = {(void*)0,(__Block_byref_bSelf_0 *)&bSelf, 33554432, sizeof(__Block_byref_bSelf_0), __Block_byref_id_object_copy_131, __Block_byref_id_object_dispose_131, self}; 

BLOCK_HAS_COPY_DISPOSE告诉内部实现，这个变量结构体具有自己的copy/dispose辅助函数，而此时我们的内部实现不会进行默认的复制操作：

   
   
  1. void _Block_object_assign(void *destAddr, const void *object, const int flags) { 
  2.     //printf("_Block_object_assign(*%p, %p, %x)\n", destAddr, object, flags); 
  3.     if ((flags & BLOCK_BYREF_CALLER) == BLOCK_BYREF_CALLER) { 
  4.         if ((flags & BLOCK_FIELD_IS_WEAK) == BLOCK_FIELD_IS_WEAK) { 
  5.             _Block_assign_weak(object, destAddr); 
  6.         } 
  7.         else { 
  8.             // do *not* retain or *copy* __block variables whatever they are 
  9.             _Block_assign((void *)object, destAddr); 
  10.         } 
  11.     } 

当我们没有开启arc，且flags中具有BLOCK_BYREF_CALLER时，会进入_Block_assign函数，而此函数仅仅是赋值

所以，如果要避免objc实例中的block引起的循环引用，我们需要让block间接使用self：

__block bSelf = self;

其他

对于dipose辅助函数，其行为与copy是类似的，我们不再重复同样的东西，如果大家要了解，自行查阅runtime.c和Block_private.h即可。

我们已经理解了非arc非gc情况下的block的内存管理内部实现，对arc和gc的情况，其行为也是类似的，只是一些函数的指针指向的真正函数会改变，比如_Block_use_GC函数，会将一些函数指向其他的实现，使其适用于gc开启的情况。

小结

block实际上是一些执行语句和语句需要的上下文的组合，而runtime给予的内部实现决定了它不会浪费一比特的内存。

我们知道cocoa中的容器类class有mutable和immutable之分，实际上我们可以将block看做一个immutable的容器，其盛放的是执行的代码和执行此代码需要的变量，而一个immutable变量的无法改变的特质，也决定了block在复制时，的确没有必要不断分配新的内存。故而其复制的行为会是增加引用计数。

转自：http://mobile.51cto.com/hot-403935.htm


junhoo_lee
关注
iOS之深入解析Block的使用和外部变量捕获
╰つ栺尖篴夢ゞ
03-16 3万+
一、前言 闭包 = 一个函数「或指向函数的指针」+ 该函数执行的外部的上下文变量「也就是自由变量」; Block是Objective-C对于闭包的实现。 其中，Block: 可以嵌套定义，定义Block方法和定义函数方法相似； Block 可以定义在方法内部或外部； 只有调用Block时候，才会执行其{}体内的代码； 本质是对象，使代码高聚合。 使用 clang 将 OC 代码转换为 C++ 文件查看block的方法: 在命令行输入代码 clang -rewrite-objc 需要编译的OC文件
BlocksRuntime:C块的运行时库支持-开源
05-27
块是对Apple开发的C，Objective C和C ++语言的扩展建议，以支持Grand Central Dispatch并发引擎。
block介绍（四）揭开神秘面纱（下）
The Life with iOS
07-12 744
终于有空开始这系列最后一篇的编写。 这一篇，我们将看到block的内存管理的内部实现，通过剖析runtime库源码，我们可以更深刻的理解block的内存运作体系。 看此篇时，请大家同时打开两个网址（或者下载它们到本地然后打开）： http://llvm.org/svn/llvm-project/compiler-rt/trunk/BlocksRuntime/runtime.c http
Runtime05Block原理
u010919133的专栏
09-14 360
例子1 main.m文件的代码如下： #import <Foundation/Foundation.h> int main(int argc, const char * argv[]) { @autoreleasepool { int age = 1; void (^myBlock)(int, int) = ^(int a, int b) { ...
iOS block 源码详解2
jeffasd的专栏
06-26 628
/* * Block_private.h * * Copyright 2008-2010 Apple, Inc. Permission is hereby granted, free of charge, * to any person obtaining a copy of this software and associated documentation * files (the
ios高效开发二--ARC跟block那点事
Andy Dufresne
10-21 2610
http://www.cnblogs.com/wqxlcdymqc/p/3227099.html block是可以捕捉上下文的特殊代码块。 block可以访问定义在block外的变量，当在block中使用时，它就会为其在作用域内的每个标量变量创建一个副本。 如果通过self拥有一个block，然后又在block中改变了实例变量，就会出错。 例如：
iOS runtime底层框架原码
09-29
在iOS开发中，Objective-C（OC）是一种主要的编程语言，而它的运行时（runtime）是其核心特性之一。...通过objc4-723，我们可以一步步揭开OC runtime的神秘面纱，学习到iOS开发中许多不为人知的细节。
iOS中的函数响应式编程思想
卓同学
05-30 428
一、前言 最近正在学习iOS底层框架，在学习RxSwift的课程时，涉及到了函数响应式编程的思想，这让我想起了在工作项目中使用到的ReactiveCocoa第三方库，它里面也使用了函数响应式编程思想，之前只是看了简单的介绍，并会使用它而已，现在必须彻底去掌握该思想–函数响应式编程（FRP(Functional Reactive Programming)）,下面就让我们一起揭开函数响应式编程思想的神秘面纱。 二、基本概念 在iOS开发中，有三种编程思想，分别是链式编程、函数式编程和响应式编程。 1、链式编程.
iOS基础框架深究之AFNetWorking day 1
qq_25813441的博客
11-26 1917
我工作6年半，一直从事业务层面的开发，iOS底层相关的东西也只是通过视频去做了解，随着年龄的变化，会发现以后的路会越来越窄，学习这个东西什么时候开始学都不晚，说不定什么时候会给你带来意想不到的事情，别管别的事情了，最起码从现在开始，慢慢丢弃身边的杂事，不要在乎眼前的那点利益，也不要刻意追求什么，踏下心做好一件事，花更多的时间在接触知识上，这是今天我对自己说的话。也是以过来人给大家的一个忠告。接下来探索一下一些优秀的开源框架，希望有一天我们，总有一天我们可以搭建出更好的框架。 AFNetWorking这个网
iOS AOP框架Aspects实现原理
wangletiancsdn的博客
11-27 306
前言 众所周知，Aspects框架运用了AOP（面向切面编程）的思想，这里解释下AOP的思想：AOP是针对业务处理过程中的切面进行提取，它所面对的是处理过程中的某个步骤或阶段，以获得逻辑过程中各部分之间低耦合性的隔离效果。也许大家用Aspects提供的两个方法用着很爽，有没有想揭开它的神秘面纱，看一下它的庐山真面目？接下来主要讲下Aspects的主要实现原理。 ruhua.gif ...
【iOS开发-117】block为什么用copy？利用runtime运行时的objc_方法为分类扩充成员变量
小小的客栈 大大的江湖
01-30 2304
block为什么用copy？利用runtime运行时的objc_方法为分类扩充成员变量
Block原理，为什么block能捕获变量 -- 原理篇
热门推荐
gcs的博客
12-02 1万+
主要参考了这些文章 , 有删改： http://www.jianshu.com/p/ee9756f3d5f6 https://www.jianshu.com/p/c99f4974ddb5 https://www.jianshu.com/p/8865ff43f30e 前言 Blocks是C语言的扩充功能，而Apple 在OS X S...
iOS 底层探索篇 ——block（下）
LinShunIos的博客
08-24 726
@[TOC](iOS 底层探索篇 —— block(下)) block底层源码 block 编译成一个什么样的结构 block invoke-> isa->签名 ->捕获 -> 保存 -> 释放 1. block底层分析 要探究block底层是什么样的一个结构，那么就定义一个block，然后xcrun 一下。 xcrun之后，打开生成的cpp文件，看到生成的main函数。 把函数的类型强转去掉之后得到下面的代码。这里看到 void(*block)(void) 等于__ma
从逆向工程角度分析iOS中block在内存中的结构
大飞哥的专栏
05-23 953
  最近在了解逆向工程，其中看到了一篇关于逆向解析支付宝的文章，文章中提到了block在内存中的存储结构，以及根据汇编代码推断block在内存中的具体地址。在这里摘出来供大家更加深入的了解block。block在内存中的结构首先，我们先分析下运行时，block在内存中的存在形式。block在内存中是以一个结构体的形式存在的，大致的结构如下：说明下block中的isa指针，根据实际情况会有三种不同的...
iOS底层探索之Block(四)——Block的探索和源码分析
俊而不逊的博客
08-30 664
Block的本质是什么吗？__Block底层又做了什么呢？ 在上一篇篇博客中，已经探索到block的本质是结构体(__main_block_impl_0)继承自__block_impl，block可以捕获外部变量，通过__block修饰内部可以变更外部变量的值。 那么本篇博客将对继续对block的底层原理进行分析。 iOS底层探索之Block(一)——初识Block(你知道几种Block呢？) iOS底层探索之Block(二)——如何解决Block循环引用问题？ iOS底层探索之Block(三)——Blo
Block背后的数据结构及变量截取
无忘无往
02-15 1628
本文的内容主要是基于Clang编译器的官方文档所写。 Clang 先说些题外话，什么是Clang？Clang是C++编写的编译器。我们知道，我们平常代码所写的任何程序，最终都需要通过编译器转换成与语言无关的机器二进制代码。而Clang，则是支持/C++/Objective-C/Objective-C++的编译器。那我们在做OC开发时，可能也会听说LLVM编译器，那么Clang和LLVM之间是什么关...
iOS Block源码分析系列（一）————2分钟明白Block究竟是什么？
Deft_MKJing的博客
11-12 5281
    Block其实就是C语言的扩充功能，实现了对C的闭包实现，一个带有局部变量的匿名函数。    Block的语法，类型介绍我这里就不BB了，网上太多了，全是介绍怎么写的，这里开几篇博客来看看block的源码和内部实现结构，网上写的很乱很杂，而且都不全，自己买了本书，开搞！！！！！！入门嘛，咱们先来一段最最最简单的代码#include "stdio.h" int main() { void ...
isa详解
More reading and learning to become excellent
07-27 1536
在arm64之前isa就是普通的指针,只存储类对象,元类对象的指针,但是arm64之后,isa做了优化,采取了共用体结构,将一个64位的内存数据分开存储了很多东西,其中33位用来存储地址值...
Block的三种类型
大兵布莱恩特
02-25 3228
block有3中类型,可以通过 class方法或者 isa 指针查看具体类型,最终都是继承与NSBlock 的类型 有__NSGlobalBlock__,NSMallocBlock,NSStackBlock 这三种 block在内存中分配的位置是不同的 那么什么样的 block 是 NSGlobalBlock?什么样的 block 是 NSMallocBlock ?什么样的 block 是__N...
iOS中的Block深入理解：为何无需WeakSelf
"这篇文章主要探讨了iOS开发中关于Block的使用，特别是如何避免因为Block导致的循环引用问题，以及在不使用weakSelf的情况下解决这一问题的方法。作者通过创建一个名为BlockTable的类，模拟展示了Block与对象间的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值