block本质探寻八之循环引用

说明：阅读本文，请参照之前的block文章加以理解；

一、循环引用的本质

//代码——ARC环境

void test1()
{
    Person *per = [[Person alloc] init];
    per.age = 10;
    per.block = ^{
        NSLog(@"-------1");
    };
}
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        test1();
//        test2();
    }

    NSLog(@"----");
    return 0;
}
#import <Foundation/Foundation.h>

NS_ASSUME_NONNULL_BEGIN

typedef void(^MyBlock)(void);

@interface Person : NSObject

@property (nonatomic, assign) int age;
@property (nonatomic, copy) MyBlock block;

@end

NS_ASSUME_NONNULL_END

#import "Person.h"

@implementation Person

- (void)dealloc
{
//    [super dealloc];
    NSLog(@"%s", __func__);
}

@end

//打印

2019-01-17 16:46:28.353740+0800 MJ_TEST[2990:240693] -[Person dealloc]
2019-01-17 16:46:28.354013+0800 MJ_TEST[2990:240693] ----
Program ended with exit code: 0

分析：main函数日志输出之前，Person实例对象就被销毁了——因为在test1()方法中，强指针per持有[[Person alloc] init]对象会执行retain操作导致Person实例对象的retainCount值为2（此前alloc操作，其retainCount值就设置为1），当test1()方法结束时，per被存放在栈区也随之销毁，故per不会再持有Person实例对象即执行release操作导致该对象的retainCount指减1；当自动销毁池autoreleasepool结束时，会自动向池中的所有对象再次发送一条release消息，那么此时Person实例对象的retainCount值再次减1变成0，对象的引用计数一旦为0，其所占内存会被自动回收，因此Person实例对象就会销毁；

补充：我们知道blcok的内存管理模式为copy策略（原因就不分析了），因为在ARC环境下强指针持有block对象，系统会自动将block对象copy到堆区中，所以ARC模式下，系统会自动帮助我们对block进行copy的管理策略，我们写成strong的策略是没有任何问题的——但是，MRC模式下必须是copy策略，系统不会帮你管理内存，只能手动；这点请注意！

至此，以上Person实例对象销毁是正常的，那么什么情况下是不正常的？往下看：

//代码

void test2()
{
    Person *per = [[Person alloc] init];
    per.age = 10;
    per.block = ^{
        NSLog(@"-------%d", per.age);
    };
}

//打印

2019-01-17 15:00:31.859710+0800 MJ_TEST[2486:187534] -----
Program ended with exit code: 0

//clang

main.cpp

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

Person.cpp

struct Person_IMPL {
    struct NSObject_IMPL NSObject_IVARS;
    int _age;
    MyBlock  _Nonnull _block;
};

struct NSObject_IMPL {
    Class isa;
};

static void(* _I_Person_block(Person * self, SEL _cmd) )(){ return (*(MyBlock  _Nonnull *)((char *)self + OBJC_IVAR_$_Person$_block)); }

static void _I_Person_setBlock_(Person * self, SEL _cmd, MyBlock  _Nonnull block) { objc_setProperty (self, _cmd, __OFFSETOFIVAR__(struct Person, _block), (id)block, 0, 1); }

分析：

<1>我们知道，oc对象编译成C++后的本质就是一个结构体Person_IMPL，该结构体的第一个成员变量就是isa指针，指向类对象本身；同时，@property修饰的属性，系统会自动生成一个结构体成员变量，还为之生成getter和setter方法——这些之前的文章已经说过，此处不再赘述！

<2>per实例对象结构体Person_IMPL中含有_block变量，通过setter法_I_Person_setBlock_将block对象（等号右边）赋值给该_block变量，因此_block指向block对象（强引用）；

<3>在__main_block_impl_0结构体中，我们看到Person *__strong per，所以，block对象本身对Person实例对象也是强引用；

综上：block对象结构体__main_block_impl_0通过其内部成员指针变量Person *__strong per持有Person实例对象（强引用），而Person实例对象结构体Person_IMPL通过其内部成员指针变量_block持有block对象（强引用）——因此二者构成循环引用，当autoreleasepool大括号结束时，block对象和Person实例对象所占内存依然没有被系统回收，因为他们的引用计数依然大于0；

//图解——注：self是一个auto型的局部变量，指向的是[[Person alloc] init]实例对象

补充：所以block循环引用造成的直接后果是内存泄露（即程序结束而内存没有被回收——>根本原因是对象引用计数大于0（retain和release使用次数不对等）——>是因为强指针引用造成的）；

引伸：当对象所占内存被回收时，指向对象的指针（强指针）应当被赋值于nil或者指向其他的合法内存，否则会导致野指针调用（乱指）程序崩溃——但是，用weak做内存管理策略（即修饰指针变量）时，为什么系统会自动将指针变量置为nil？这点后面文章会提到！

二、解决方案

思路：

据上分析，打破循环引用，只需要将其中一个强引用变成弱引用即可，那么要改变哪一个弱引用呢？Person实例对象内部拥有block属性，当该实例对象销毁时，其block属性也会随之销毁，所以我们只需要将block对象中的Person类型指针变成弱指针即可——通常都是这样做！

//图解

1）ARC环境下

方案一：weak修饰

//代码

void test3()
{
    Person *per = [[Person alloc] init];
    per.age = 10;
    __weak Person *weakPer = per;
    per.block = ^{
        NSLog(@"-------%d", weakPer.age);
    };
}

//打印

2019-01-18 14:10:17.451718+0800 MJ_TEST[1458:103419] -[Person dealloc]
2019-01-18 14:10:17.452663+0800 MJ_TEST[1458:103419] ----
Program ended with exit code: 0

//clang

struct __test3_block_impl_0 {
  struct __block_impl impl;
  struct __test3_block_desc_0* Desc;
  Person *__weak weakPer;
  __test3_block_impl_0(void *fp, struct __test3_block_desc_0 *desc, Person *__weak _weakPer, int flags=0) : weakPer(_weakPer) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

分析：

<1>block对象中，Person指针变量类型变成了__weak类型，打印前person对象销毁了；

<2>另外一种写法：__weak typeof(per) weakPer = per  <=>  __weak Person *weakPer = per;（前者写法居多）

方案二：__unsafe_unretained修饰

注：__weak修饰和__unsafe_unretained，二者有一个非常重要的区别：

经上分析，我们知道Person实例对象销毁后，其内部的block属性也会销毁，那么其也就不再指向block对象了，而此时一旦block对象没有任何强引用，作用域结束后，其也会被销毁，其成员变量Person指针也会被销毁，这点没问题！————但是，如果block对象还存在呢（被其他指针强引用），此时其内部成员变量Person指针也存在，但是依然会指向Person实例对象销毁前所占的内存区域，但是该内存区域已经被系统回收了，Person指针指向的是不合法的内存区域——如果是weak修饰，系统会自动将指针置为nil（指向合法的内存区域）；如果是__unsafe_unretained修饰，什么也不会做，这样就会导致野指针调用！

方案三：__block修饰

//代码

void test4()
{
    __block Person *per = [[Person alloc] init];
    per.age = 10;
    per.block = ^{
        NSLog(@"-------%d", per.age);
        per = nil;
    };
    per.block();
}

//打印

2019-01-18 15:20:06.697898+0800 MJ_TEST[1810:136831] -------10
2019-01-18 15:20:06.698250+0800 MJ_TEST[1810:136831] -[Person dealloc]
2019-01-18 15:20:06.698300+0800 MJ_TEST[1810:136831] ----
Program ended with exit code: 0

//clang

struct __Block_byref_per_0 {
  void *__isa;
__Block_byref_per_0 *__forwarding;
 int __flags;
 int __size;
 void (*__Block_byref_id_object_copy)(void*, void*);
 void (*__Block_byref_id_object_dispose)(void*);
 Person *__strong per;
};

struct __test4_block_impl_0 {
  struct __block_impl impl;
  struct __test4_block_desc_0* Desc;
  __Block_byref_per_0 *per; // by ref
  __test4_block_impl_0(void *fp, struct __test4_block_desc_0 *desc, __Block_byref_per_0 *_per, int flags=0) : per(_per->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

分析：

<1>block对象持有__block对象，而__block对象又持有Person实例对象，而Person实例对象又持有block对象——如此，构成一个三角循环：

<2>通过block回调，Person实例对象指针被置为nil，而该指针本质是__block对象中的Person *__strong per指针，因此该指针不可能再指向Person实例对象了，所以，第2条持有就断开了，打破了三角循环；

说明：但是该方案看起来比较麻烦，一旦忘记将指针置为nil，就会造成内存泄露；

注：以上分析不理解，请参考前述block文章，此处不再赘述！

2）MRC环境

说明：该环境下不支持__weak修饰；

方案一：__unsafe_unretained修饰

//代码

void test5()
{
//    __unsafe_unretained Person *per = [[Person alloc] init];
    __block Person *per = [[Person alloc] init];
    per.age = 10;
    per.block = [^{
        NSLog(@"-------%d", per.age);
    } copy];
    [per release];
    per = nil;
}

//打印

2019-01-18 16:42:49.970441+0800 MJ_TEST[2257:177470] -[Person dealloc]
2019-01-18 16:42:49.971587+0800 MJ_TEST[2257:177470] ----
Program ended with exit code: 0

分析：

<1>根据习惯，MRC环境下，我们通常会将block对象（等号右边）从栈区copy到堆区，以达到手动控制其内存销毁的目的；

<2>原理：调用alloc创建对象时，系统会自动将该实例对象引用计数置为1，而该对象又会随着block的copy而一起被copy到堆区，此时该对象的retainCount会加1（变成2），当对该对象发送release消息时，其retainCount自动减1（由2变成1），所以当程序结束时，Person实例对象retainCount为1（>0），其内存并不会被系统回收从而导致内存泄露；

那么，__unsafe_unretained修饰后，无论后面有多少次retain或者copy操作，Person实例对象的retainCount始终为1，所以程序结束前release时，其retainCount值变为0，此时内存被回收，而不会导致内存泄露的问题；

方案二：__block修饰

分析：为什么block可以？

<1>前述文章我们分析到，MRC环境下，__block修饰对象类型的auto局部变量，系统生成的__block对象并不会根据其内存成员变量Person指针变量（其实就是test5()方法中的per指针）是强指针类型而对Person实例对象（[[Person alloc] init]）进行retain操作（强引用）；

<2>所以此时，__block的作用相当于__unsafe_unretained的作用，原理一样；

补充一个问题：在ARC环境下，弱指针不能通过"->"形式来访问对象的成员变量

原因：就是weakSelf很可能为为空（即有可能提前被释放了），所以必须使用强指针来访问

//代码

Person.m

- (void) test6
{
    __weak typeof(self) weakSelf = self;
    self.block = ^{
        __strong typeof(weakSelf) strongSelf = weakSelf;
        NSLog(@"-------%d", strongSelf->_age);
    };
}

main.m

int main(int argc, const char * argv[]) {
    @autoreleasepool {
//        test1();
//        test2();
//        test3();
//        test4();
//        test5();
        Person *per = [[Person alloc] init];
        [per test6];
    }

    NSLog(@"----");
    return 0;
}

//打印

2019-01-18 17:43:41.010848+0800 MJ_TEST[2557:208583] -[Person dealloc]
2019-01-18 17:43:41.011346+0800 MJ_TEST[2557:208583] ----
Program ended with exit code: 0

//clang

Person.m

struct __Person__test6_block_impl_0 {
  struct __block_impl impl;
  struct __Person__test6_block_desc_0* Desc;
  Person *const __weak weakSelf;
  __Person__test6_block_impl_0(void *fp, struct __Person__test6_block_desc_0 *desc, Person *const __weak _weakSelf, int flags=0) : weakSelf(_weakSelf) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

分析：block对象的内部成员变量weakSelf依然是weak类型，并不受block代码块内部的__strong转化，该转化只是为了骗取编译器通过编译而已；

三、结论

1）原因：block对象与OC对象相互持有（强引用）——OC对象有block属性，block代码块中用到了该实例对象；

2）危害：程序结束时，相互强应用（对象的引用计数>0）导致实例对象所占内存不能及时被系统回收——即内存泄露；

3）解决：

<1>ARC：__weak修饰（常用）、__unsafe_unretained（会引起野指针调用，不推荐）、__block（过于繁琐，不推荐）；

<2>MRC：__unsafe_unretained和__block；

GitHub

原文地址：https://www.cnblogs.com/lybSkill/p/10283498.html

时间： 2024-11-09 15:14:03

block本质探寻八之循环引用的相关文章

如何避免在Block里用self造成循环引用

一般来说我们总会在设置Block之后,在合适的时间回调Block,而不希望回调Block的时候Block已经被释放了,所以我们需要对Block进行copy,copy到堆中,以便后用. 当一个Block被Copy的时候,如果你在Block里进行了一些调用,那么将会有一个强引用指向这些调用方法的调用者,有两个规则: 如果你是通过引用来访问一个实例变量,那么将强引用至self 如果你是通过值来访问一个实例变量,那么将直接强引用至这个"值"变量 苹果官方文档里有两个例子来说明这两种情况: 上面

iOS 面试题（四）：block 什么时候需要构造循环引用 --转自唐巧

问题 有没有这样一个需求场景,block 会产生循环引用,但是业务又需要你不能使用 weak self? 如果有,请举一个例子并且解释这种情况下如何解决循环引用问题. 答案 需要不使用 weak self 的场景是:你需要构造一个循环引用,以便保证引用双方都存在.比如你有一个后台的任务,希望任务执行完后,通知另外一个实例.在我们开源的 YTKNetwork 网络库的源码中,就有这样的场景. 在 YTKNetwork 库中,我们的每一个网络请求 API 会持有回调的 block,回调的 block

block本质探寻七之内存管理

说明: <1>阅读本问,请参照block前述文章加以理解: <2>环境:ARC: <3>变量类型:基本数据类型或者对象类型的auto局部变量: 一.三种情形 //代码 void test1() { int num = 10; __block int age = 20; Person *per = [[Person alloc] init]; void(^block)(void) = ^{ NSLog(@"%d %d %p", num, age, pe

block中self会造成循环引用问题

将代码块中的 self换成unsafeSelf __unsafe_unretained 与 __weak 99%相同 __weak 当对象释放之后 会自动设置为nil 而__unsafe_unretained不会

iOS Block循环引用

前言 本篇文章精讲iOS开发中使用Block时一定要注意内存管理问题,很容易造成循环引用.本篇文章的目标是帮助大家快速掌握使用block的技巧. 我相信大家都觉得使用block给开发带来了多大的便利,但是有很多开发者对block内存管理掌握得不够好,导致经常出现循环引用的问题.对于新手来说,出现循环引用时,是很难去查找的,因此通过Leaks不一定能检测出来,更重要的还是要靠自己的分析来推断出来. 声景一:Controller之间block传值 现在,我们声明两个控制器类,一个叫ViewContr

IOS中Block的循环引用

@interface DemoObj() @property (nonatomic, strong) NSOperationQueue *queue; @end @implementation DemoObj - (instancetype)init { self = [super init]; if (self) { self.queue = [[NSOperationQueue alloc] init]; } return self; } - (void)dealloc { NSLog(@"

iOS Block循环引用精讲

前言 循环引用就是当self 拥有一个block的时候,在block 又调用self的方法.形成你中有我,我中有你,谁都无法将谁释放的困局.又或者解决方法简而言之就一句话的事情:__weak typeof (self) weakSelf = self; 本篇文章精讲iOS开发中使用Block时一定要注意内存管理问题,很容易造成循环引用.本篇文章的目标是帮助大家快速掌握使用block的技巧. 我相信大家都觉得使用block给开发带来了多大的便利,但是有很多开发者对block内存管理掌握得不够好,导

iOS容易造成循环引用的几种场景

建议两篇都要看,各有长处 原文1:http://cache.baiducontent.com/c?m=9f65cb4a8c8507ed4fece763105392230e54f7636d918d027fa3c215cc7902155a66e1b821201b19d2c47c640aae5e5c9daa702d691765eadb9e871a83e6c37138895723061f913264c469dfdc3620d621e04d9faf0e93cce74492b9a3d2&p=8778c54a

常见的出现内存循环引用的场景有哪些？

定时器(NSTimer):NSTimer经常会被作为某个类的成员变量,而NSTimer初始化时要指定self为target,容易造成循环引用(self->timer->self). 另外,若timer一直处于validate的状态,则其引用计数将始终大于0,因此在不再使用定时器以后,应该先调用invalidate方法 block的使用:block在copy时都会对block内部用到的对象进行强引用(ARC)或者retainCount增1(非ARC).在ARC与非ARC环境下对block使用不当