在讲block的循环引用问题之前，我们需要先了解一下iOS的内存管理机制和block的基本知识。

iOS的内存管理机制
Objective-C在iOS中不支持GC(垃圾回收)机制，而是采用的引用计数的方式管理内存。
引用计数(Reference Count)：在引用计数中，每一个对象负责维护对象所有的引用的计数值，当一个新的引用指向对象时，引用计数器就递增，当去掉一个引用时，引用计数就递减，当引用计数到零时，该对象就将释放占有的资源。我们通过开关房间的灯为例来说明引用计数机制。

引用计数-1

在Objective-C中，”对象”相当于办公室的照明设备，”对象的使用环境”相当于进入办公室的人。上班进入办公室的人对办公室照明设备发出的动作，与Objective-C中的对应关系如下表

i引用计数-1

使用计数功能计算需要照明的人数，使办公室的照明得到了很好的管理。同样，使用引用计数功能，对象也就能得到很好的管理，这就是Objective-C内存管理，如下图所示

引用计数-2

MRC(Manual Reference Counting)中引起引用计数变化的方法

引用计数-3

ARC(Automatic Reference Counting)中内存管理

引用计数-4

循环引用的问题
两个对象相互持有，这样就会造成循环引用，如下图所示

循环引用-1

block中循环引用问题
由于block会对block中的对象进行持有操作，就相当于持有了其中的对象，而如果此时block中的对象又持有了该block，则会造成循环引用。如下，

typedef void(^block)();

@property (nonatomic, copy) block myBlock;
@property (nonatomic, copy) NSString *blockString;

-(void)testBlock 
{
     self.myBlock = ^{
          //其实注释中的代码，同样会造成循环引用
          NSString *localString = self.blockString;
          //NSString *localString = _blockString;
          //[self doSomething];
     };
}

注：以下调用注释掉的代码同样会造成循环引用，因为不管是通过self.blockString 还是 _blockString，或是函数调用[self doSomething]，因为只要block中用到了对象的属性或者函数，block就会持有该对象而不是该对象中的某个属性或者函数。当someObj持有self对象，此时的关系图如下

循环引用-2

当someObj对象release self对象时，self和myBlock相互引用，retainCount都为1，造成循环引用

循环引用-3

__weak typeof(self) weakSelf = self;
self.myBlock = ^{
      NSString *localString = weakSelf.blockString; 
};

使用__weak修饰self，使其在block中不被持有，打破循环引用。开始状态如下

循环引用-4

当someObj对象释放self对象时，self的retainCount为0，走dealloc，释放myBlock对象，使其retainCount也为0。

循环引用-5

//ClassB
@interface ClassB : NSObject
@property (strong, nonatomic) ClassA *objA;
-(void)doSomething;
@end

//ClassA
@interface ClassA : NSObject
@property (strong, nonatomic) ClassB *objB;
@property (copy, nonatomic) block myBlock;
@end

@implementation  ClassA
-(void)testBlockRetainCycle
{
      ClassB *objB = [[ClassB alloc] init];
      self.myBlock = ^ {
          [objB doSomething];
      };
      objB.objA = self;
}
@end

循环引用-6

解决方法：

-(void)testBlockRetainCycle
{
      ClassB *objB = [[ClassB alloc] init];
      __weak typeof(objB) weakObjB = objB; 
      self.myBlock = ^ {
          [weakObjB doSomething];
      };
      objB.objA = self;
}

将objB对象weak，使其不在block中被持有。
注：以上使用__weak打破循环引用的方法只在ARC下才有效，在MRC下应该使用__block或者在block执行完后，将block置nil，这样也可以打破循环引用

-(void)testBlockRetainCycle
{
      ClassB *objB = [[ClassB alloc] init];
      self.myBlock = ^ {
          [objB doSomething];
      };
      objB.objA = self;
      self.myBlock();
      self.myBlock = nil;
}

这样做的缺点是，block只会执行一次，因为block被置nil了，要再次使用的话，需要重新赋值。

一些不会造成循环引用的block
在开发工程中，发现一些同学并没有完全理解循环引用，以为只要有block的地方就会要用__weak来修饰对象，这样完全没有必要，以下几种block是不会造成循环引用的。

• 大部分GCD方法

dispatch_async(dispatch_get_main_queue(), ^{       [self doSomething];
});

因为self并没有对GCD的block进行持有，没有形成循环引用。目前我还没碰到使用GCD导致循环引用的场景，如果某种场景self对GCD的block进行了持有，则才有可能造成循环引用。

• block并不是属性值，而是临时变量

-(void)doSomething 
{
       [self testWithBlock:^{
              [self test];
       }];
}

-(void)testWithBlock:(void(^)())block {
        block();
}

-(void)test
{
     NSLog(@“test”);
}

这里因为block只是一个临时变量，self并没有对其持有，所以没有造成循环引用。

block使用对象被提前释放
看下面例子，有这种情况，如果不只是ClassA持有myBlock，ClassB也持有了myBlock。

循环引用-7

循环引用-8

另一个常见错误使用是，开发者担心循环引用错误(如上所述不会出现循环引用的情况)，使用__weak。比如

__weak typeof(self) weakSelf = self;
dispatch_async(dispatch_get_main_queue(), ^{
     [weakSelf doSomething];
});

因为将block作为参数传给dispatch_async时，系统会将block拷贝到堆上，而且block会持有block中用到的对象，因为dispatch_async并不知道block的对象会在什么时候释放，为了确保系统调度执行block中的任务时其对象没有被意外释放掉，dispatch_async必须自己retain一次对象(即self)，任务完成后再release对象(即self)。但这里使用__weak,使dispatch_async没有增加self的引用计数，这使得在系统在调度执行block之前，self可能已被销毁，但系统并不知道这个情况，导致block执行时访问已经被释放的self，而达不到预期的结果。

注：如果是在MRC模式下，使用__block修饰self，则此时block访问被释放的self，则会导致crash。

//ClassA.m
-(void)test 
{
      __weak MyClass *weakSelf = self;
     double delayInSeconds = 10.0f;
     dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delayInSeconds * NSEC_PER_SEC));
    dispatch_after(popTime, dispatch_get_main_queue(), ^(void){
         NSLog(@“%@”, weakSelf);
   });
}

//ClassB.m
-(void)doSomething
{
     NSLog(@“do something”);
     ClassA *objA = [[ClassA alloc] init];
     [objA test];
}

运行结果

循环引用-9

解决方法:
对于这种场景，就不应该使用__weak来修饰对象，让dispatch_after对self进行持有，保证block执行时self还未被释放

block执行过程中对象被释放
还有一种场景，在block执行开始时self对象还未被释放，而执行过程中，self被释放了，此时访问self时，就会发生错误。对于这种场景，应该在block中对对象使用__strong修饰，使得在block期间对对象持有，block执行结束后，解除其持有。

-(void)testBlockRetainCycle
{
      ClassB *objB = [[ClassB alloc] init];
      __weak typeof(objB) weakObjB = objB;
      self.myBlock = ^ {
          __strong typeof(weakObjB) strongWeakObjB = weakObjB;
          [strongWeakObjB doSomething];
      };
      objB.objA = self
}

注：此方法只能保证在block执行期间对象不被释放，如果对象在block执行之前已经被释放了，该方法也无效。