拔个牙了酸二狗 發表於 2020-5-8 15:54:00

iOS开发——Block内存管理实例分析

<p>说道block大家都不陌生，内存管理问题也是开发者最头疼的问题，网上很多讲block的博客，但大都是理论性多点，今天结合一些实例来讲解下。</p>
<h3 id="存储域">存储域</h3>
<p>首先和大家聊聊block的存储域，根据block在内存中的位置，block被分为三种类型：</p>
<ul>
<li><strong>NSGlobalBlock</strong></li>
<li><strong>NSStackBlock</strong></li>
<li><strong>NSMallocBlock</strong></li>
</ul>
<p>从字面意思上大家也可以看出来<br>
1、<strong>NSGlobalBlock</strong>是位于全局区的block，它是设置在程序的数据区域（.data区）中。<br>
2、<strong>NSStackBlock</strong>是位于栈区，超出变量作用域，栈上的Block以及 ____block__变量都被销毁。<br>
3、<strong>NSMallocBlock</strong>是位于堆区，在变量作用域结束时不受影响。</p>
<blockquote>
<p>注意：在 ARC 开启的情况下，将只会有 NSConcreteGlobalBlock 和 NSConcreteMallocBlock 类型的 block。</p>
</blockquote>
<blockquote>
<p><strong>作为一个开发者，有一个学习的氛围跟一个交流圈子特别重要，这是一个我的iOS交流群：413038000，不管你是小白还是大牛欢迎入驻 ，分享BAT,阿里面试题、面试经验，讨论技术， 大家一起交流学习成长！</strong></p>
</blockquote>
<h4 id="推荐阅读ios开发2020-最新-bat面试题合集持续更新中">推荐阅读：iOS开发——2020 最新 BAT面试题合集（持续更新中）</h4>
<p>说了这么多理论的东西，有些人可能很懵，觉得讲这些有什么用呢，我平时使用block并没有什么问题啊，好了，接下来我们先来个🌰感受下：</p>
<pre><code>#import "ViewController.h"

void(^block)(void);
@implementation ViewController

- (void)viewDidLoad {
    ;

    NSInteger i = 10;
    block = ^{
      NSLog(@"%ld", i);
    };
}

- (void)touchesBegan:(NSSet&lt;UITouch *&gt; *)touches withEvent:(UIEvent *)event {
    block();
}

@end

</code></pre>
<p>声明这样一个block，点击屏幕的时候去调用这个block，然后就会发生以下错误：</p>
<p><img src="//upload-images.jianshu.io/upload_images/1062284-00f75c1e59f157f7.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1135/format/webp"></p>
<p>野指针错误，显而易见，这个是生成在栈上的block，因为超出了作用域而被释放，所以再调用的时候报错了，通过打印这个block我们也可以看到是生成在栈上的：</p>
<p><img src="//upload-images.jianshu.io/upload_images/1062284-b9cf4d71f3cc4892.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/395/format/webp"></p>
<h2 id="解决办法">解决办法</h2>
<p>解决办法呢有两种：</p>
<ul>
<li>一、Objective-C为块常量的内存管理提供了复制（Block_copy()）和释放（Block_release()）命令。 使用Block_copy()命令可以将块常量复制到堆中，这就像实现了一个将块常量引用作为输入参数并返回相同类型块常量的函数。</li>
</ul>
<pre><code>- (void)viewDidLoad {
    ;

    NSInteger i = 10;
    block = Block_copy(^{
      NSLog(@"%ld", i);
    });
}

</code></pre>
<p>为了避免内存泄漏，Block_copy()必须与相应的Block_release()命令达到平衡：</p>
<pre><code>Block_release(block);

</code></pre>
<ul>
<li>二、Foundation框架提供了处理块的copy和release方法，这两个方法拥有与Block_copy()和Block_release()函数相同的功能：</li>
</ul>
<pre><code>- (void)viewDidLoad {
    ;

    NSInteger i = 10;
    block = [^{
      NSLog(@"%ld", i);
    } copy];
}

</code></pre>
<pre><code>;

</code></pre>
<p>到这里有人可能会有疑问了，为什么相同的代码我建了一个工程，没有调用copy，也没有报错啊，并且可以正确打印。 那是因为我们上面的操作都是在MRC下进行的，ARC下编译器已经默认执行了copy操作，所以上面的这个例子就解释了Block超出变量作用域可存在的原因。</p>
<p>接下来可能有人又要问了，block什么时候在全局区，什么时候在栈上，什么时候又在堆上呢？上面的例子是对生成在栈上的Block作了copy操作，如果对另外两种作copy操作，又是什么样的情况呢？</p>
<table>
<thead>
<tr>
<th>Block的类</th>
<th>配置存储域</th>
<th>复制效果</th>
</tr>
</thead>
<tbody>
<tr>
<td>_NSConcreteGlobalBlock</td>
<td>程序数据区域</td>
<td>什么也不做</td>
</tr>
<tr>
<td>_NSConcreteStackBlock</td>
<td>栈</td>
<td>从栈复制到堆上</td>
</tr>
<tr>
<td>_NSConcreteMallocBlock</td>
<td>堆</td>
<td>引用计数加增加</td>
</tr>
</tbody>
</table>
<p>通过这张表我们可以清晰看到三种Block copy之后到底做了什么，接下来我们就来分别看看这三种类型的Block。</p>
<h3 id="nsglobalblock">NSGlobalBlock</h3>
<p>在记述全局变量的地方使用block语法时，生成的block为_NSConcreteGlobalBlock类对象</p>
<pre><code>void(^block)(void) = ^ { NSLog(@"Global Block");};
int main() {

}

</code></pre>
<p>在代码不截获自动变量时，生成的block也是在全局区：</p>
<pre><code>int(^block)(int count) = ^(int count) {
      return count;
    };
block(2);

</code></pre>
<p>但是通过clang改写的底层代码指向的是栈区：</p>
<pre><code>impl.isa = &amp;_NSConcreteStackBlock

</code></pre>
<blockquote>
<p>这里引用巧神的一段话：由于 clang 改写的具体实现方式和 LLVM 不太一样，并且这里没有开启 ARC。所以这里我们看到 isa 指向的还是_NSConcreteStackBlock。但在 LLVM 的实现中，开启 ARC 时，block 应该是 _NSConcreteGlobalBlock 类型</p>
</blockquote>
<p>总结下,生成在全局区block有两种情况：</p>
<ul>
<li>定义全局变量的地方有block语法时</li>
<li>block语法的表达式中没有使用应截获的自动变量时</li>
</ul>
<h3 id="nsstackblock">NSStackBlock</h3>
<p>配置在全局区的block，从变量作用域外也可以通过指针安全地使用。但是设置在栈上的block，如果其作用域结束，该block就被销毁。同样的，由于<code>__block</code>变量也配置在栈上，如果其作用域结束，则该<code>__block</code>变量也会被销毁。<br>
上面举得例子其实就是生成在栈上的block：</p>
<pre><code>NSInteger i = 10;
block = ^{
   NSLog(@"%ld", i);
};

</code></pre>
<p>除了配置在程序数据区域的block（全局Block），其余生成的block为_NSConcreteStackBlock类对象，且设置在栈上，那么配置在堆上的__NSConcreteMallocBlock类何时使用呢？</p>
<h3 id="nsmallocblock">NSMallocBlock</h3>
<p>Blocks提供了将Block和__block变量从栈上复制到堆上的方法来解决这个问题，这样即使变量作用域结束，堆上的Block依然存在。</p>
<pre><code>impl.isa = &amp;_NSConcreteMallocBlock;

</code></pre>
<p>这也是为什么Block超出变量作用域还可以存在的原因。</p>
<blockquote>
<p>那么什么时候栈上的Block会复制到堆上呢？</p>
</blockquote>
<ul>
<li>调用Block的copy实例方法时</li>
<li>Block作为函数返回值返回时</li>
<li>将Block赋值给附有__strong修饰符id类型的类或Block类型成员变量时</li>
<li>将方法名中含有usingBlock的Cocoa框架方法或GCD的API中传递Block时</li>
</ul>
<p>上面只对Block进行了说明，其实在使用<code>__block</code>变量的Block从栈上复制到堆上时，<code>__block</code>变量也被从栈复制到堆上并被Block所持有。</p>
<p>接下来我们再来看一个🌰：</p>
<pre><code>void(^block)(void);

int main(int argc, const char * argv[]) {
    @autoreleasepool {

      __block NSInteger i = 10;
      block = [^{
            ++i;
      } copy];

      ++i;

      block();

      NSLog(@"%ld", i);
    }
    return 0;
}

</code></pre>
<p>我们对这个生成在栈上的block执行了copy操作,Block和<code>__block</code>变量均从栈复制到堆上。<br>
然后在Block作用域之后我们又使用了与Block无关的变量：</p>
<pre><code>++i;

</code></pre>
<p>一个是存在于栈上的变量，一个是复制到堆上的变量，我们是如何做到正确的访问这个变量值的呢？</p>
<p>通过clang转换下源码来看下：</p>
<pre><code>void(*block)(void);

struct __Block_byref_i_0 {
void *__isa;
__Block_byref_i_0 *__forwarding;
int __flags;
int __size;
NSInteger i;
};

struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
__Block_byref_i_0 *i; // by ref
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_i_0 *_i, int flags=0) : i(_i-&gt;__forwarding) {
    impl.isa = &amp;_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
__Block_byref_i_0 *i = __cself-&gt;i; // bound by ref

            ++(i-&gt;__forwarding-&gt;i);
      }
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&amp;dst-&gt;i, (void*)src-&gt;i, 8/*BLOCK_FIELD_IS_BYREF*/);}

static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src-&gt;i, 8/*BLOCK_FIELD_IS_BYREF*/);}

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};
int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;

      __attribute__((__blocks__(byref))) __Block_byref_i_0 i = {(void*)0,(__Block_byref_i_0 *)&amp;i, 0, sizeof(__Block_byref_i_0), 10};
      block = (void (*)())((id (*)(id, SEL))(void *)objc_msgSend)((id)((void (*)())&amp;__main_block_impl_0((void *)__main_block_func_0, &amp;__main_block_desc_0_DATA, (__Block_byref_i_0 *)&amp;i, 570425344)), sel_registerName("copy"));

      ++(i.__forwarding-&gt;i);

      ((void (*)(__block_impl *))((__block_impl *)block)-&gt;FuncPtr)((__block_impl *)block);

      NSLog((NSString *)&amp;__NSConstantStringImpl__var_folders_47_s4m8c9pj5mg0k9mymsm7rbmw0000gn_T_main_e69554_mi_0, (i.__forwarding-&gt;i));
    }
    return 0;
}
static struct IMAGE_INFO { unsigned version; unsigned flag; } _OBJC_IMAGE_INFO = { 0, 2 };

</code></pre>
<p>我们发现相比于没有<code>__block</code>关键字修饰的变量，源码中增加了一个名为 __Block_byref_i_0 的结构体，用来保存我们要 capture 并且修改的变量 i。</p>
<p>在__Block_byref_i_0结构体中我们可以看到成员变量<code>__forwarding</code>,它持有指向该实例自身的指针。那么为什么会有这个成员变量<code>__forwarding</code>呢？这也是正是问题的关键。<br>
我们可以看到源码中这样一句：</p>
<pre><code>++(i-&gt;__forwarding-&gt;i);

</code></pre>
<p>栈上的<code>__block</code>变量复制到堆上时，会将成员变量<code>__forwarding</code>的值替换为复制到堆上的<code>__block</code>变量用结构体实例的地址。所以“不管<code>__block</code>变量配置在栈上还是堆上，都能够正确的访问该变量”，这也是成员变量<code>__forwarding</code>存在的理由。</p>
<h3 id="循环引用">循环引用</h3>
<p>循环引用比较简单，造成循环引用的原因无非就是对象和block相互强引用，造成谁都不能释放，从而造成了内存泄漏。基本的一些例子我就不再重复了，网上很多，也比较简单，我就一个问题来讨论下，也是开发中有人问过我的一个问题：</p>
<ul>
<li>** block里面使用self会造成循环引用吗？ **</li>
</ul>
<p>很显然答案不都是，有些情况下是可以直接使用self的，比如调用系统的方法：</p>
<pre><code>[UIView animateWithDuration:0.5 animations:^{
      NSLog(@"%@", self);
    }];

</code></pre>
<p>因为这个block存在于静态方法中，虽然block对self强引用着，但是self却不持有这个静态方法，所以完全可以在block内部使用self。</p>
<p>还有一种情况：<br>
当block不是self的属性时，self并不持有这个block，所以也不存在循环引用</p>
<pre><code>void(^block)(void) = ^() {
      NSLog(@"%@", self);
    };
block();

</code></pre>
<p>只要我们抓住循环引用的本质，就不难理解这些东西。</p>
<blockquote>
<p>最后附上巧神对Block底层源码实现的讲解，讲的很透彻，分析的很好！</p>
</blockquote>
<h5 id="希望可以通过上面的一些例子可以让大家加深对block的理解知其然并且知其所以然">希望可以通过上面的一些例子，可以让大家加深对block的理解，知其然并且知其所以然。</h5>
<p><img src="https://upload-images.jianshu.io/upload_images/12311242-ffb0cdda5d1f85bd.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240"></p><br><br>
来源：https://www.cnblogs.com/iOSer1122/p/12850957.html
頁: [1]
查看完整版本: iOS开发——Block内存管理实例分析