FBRetainCycleDetector循环检测流程梳理

1. 使用方式

FBRetainCycleDetector 用于检测循环引用，支持block、timer、associateObj等使用造成的循环引用问题。

主类： FBRetainCycleDetector。

使用姿势如下：

- (void)detectRetainCycle
{
    FBRetainCycleDetector *detector = [FBRetainCycleDetector new];
    [detector addCandidate:self.anobj];
    [detector addCandidate:self.associatedObj];
    [detector addCandidate:self.timer];
    NSSet *retainCycles = [detector findRetainCycles];
    NSLog(@"retainCycles : %@", retainCycles);
}
/*
timer与viewcontroller的循环引用问题：
2020-11-01 17:30:39.329350+0800 test[31600:984187] retainCycles : {(
        (
        "-> ViewController ",
        "-> _timer -> __NSCFTimer "
    )
)}
*/

2. FBRetainCycleDetector介绍

FBRetainCycleDetector（以下简称FB）是一款借助runtime分析发现循环引用的库。

FB将检测循环引用问题，转化为图的深度优先遍历。在遍历过程中检测路径上是否有环：如果有环，说明发生了循环引用；反之，则没有。

检测的关键，在于获取obj（待检测根对象）的所有强引用分支。

1. 首先，获取obj所有强引用对象

1. 获取class中声明的强引用

NSArray<id<FBObjectReference>> *FBGetObjectStrongReferences(id obj, NSMutableDictionary<Class, NSArray<id<FBObjectReference>> *> *layoutCache) 
{
  NSMutableArray<id<FBObjectReference>> *array = [NSMutableArray new];
    
  __unsafe_unretained Class previousClass = nil;
  __unsafe_unretained Class currentClass = object_getClass(obj);
    
  while (previousClass != currentClass) {
    NSArray<id<FBObjectReference>> *ivars;
    
    if (layoutCache && currentClass) { // 先查缓存
      ivars = layoutCache[currentClass];
    }
    
    if (!ivars) {
       // 获取所有强引用的ivar
      ivars = FBGetStrongReferencesForClass(currentClass);
      if (layoutCache && currentClass) { // 进行缓存
        layoutCache[currentClass] = ivars;
      }
    }
    [array addObjectsFromArray:ivars];
    previousClass = currentClass;
    currentClass = class_getSuperclass(currentClass);
  }
  return [array copy];
}

2. 获取与obj绑定的所有强引用

需要先hook系统的objc_setAssociatedObject方法；然后，通过associationsForObject获取obj的所有强引用对象。

int main(int argc, char * argv[]) {
    NSString * appDelegateClassName;
    @autoreleasepool {
        // Setup code that might create autoreleased objects goes here.
        appDelegateClassName = NSStringFromClass([AppDelegate class]);
    }
    [FBAssociationManager hook];
    return UIApplicationMain(argc, argv, nil, appDelegateClassName);
}

+ (NSArray *)associationsForObject:(id)object
{
#if _INTERNAL_RCD_ENABLED
  return FB::AssociationManager::associations(object);
#else
  return nil;
#endif //_INTERNAL_RCD_ENABLED
}

3. 如果obj为timer，获取timer的强引用

NSMutableSet *retained = [[super allRetainedObjects] mutableCopy];
    
CFRunLoopTimerContext context;
CFRunLoopTimerGetContext((CFRunLoopTimerRef)timer, &context);
    
// If it has a retain function, let's assume it retains strongly
if (context.info && context.retain) {
_FBNSCFTimerInfoStruct infoStruct = *(_FBNSCFTimerInfoStruct *)(context.info);
if (infoStruct.target) {
  FBObjectiveCGraphElement *element = FBWrapObjectGraphElementWithContext(self, infoStruct.target, self.configuration, @[@"target"]);
      if (element) {
        [retained addObject:element];
      }
    }
    if (infoStruct.userInfo) {
      FBObjectiveCGraphElement *element = FBWrapObjectGraphElementWithContext(self, infoStruct.userInfo, self.configuration, @[@"userInfo"]);
      if (element) {
        [retained addObject:element];
      }
    }
  }

4. 如果obj为block，获取obj的强引用

获取block强引用对象在block中偏移量

static NSIndexSet *_GetBlockStrongLayout(void *block) 
{    
    struct BlockLiteral *blockLiteral = block;   
    /**
    如果block有c++的构造/析构函数；或block没有dispose函数就直接返回nil
    */
    if ((blockLiteral->flags & BLOCK_HAS_CTOR)
      || !(blockLiteral->flags & BLOCK_HAS_COPY_DISPOSE)) 
    {
        return nil;
    }
        
    void (*dispose_helper)(void *src) = blockLiteral->descriptor->dispose_helper;
    const size_t ptrSize = sizeof(void *);
        
    // Figure out the number of pointers it takes to fill out the object, rounding up.
    const size_t elements = (blockLiteral->descriptor->size + ptrSize - 1) / ptrSize;
        
    // 伪造了一个和block同样布局的obj
    void *obj[elements];
    void *detectors[elements];
        
    for (size_t i = 0; i < elements; ++i) {
        FBBlockStrongRelationDetector *detector = [FBBlockStrongRelationDetector new];
        obj[i] = detectors[i] = detector;
    }
    
    // 对obj调用dispose函数，查看是哪个detector会调用release方法
    @autoreleasepool {
        dispose_helper(obj);
    }
    // 
    NSMutableIndexSet *layout = [NSMutableIndexSet indexSet];
    for (size_t i = 0; i < elements; ++i) {
        FBBlockStrongRelationDetector *detector = (FBBlockStrongRelationDetector *)(detectors[i]);
        if (detector.isStrong) { // 找到调用release方法的detector是第几个，也就是真实block中强引用的对象的偏移量
          [layout addIndex:i];
        }
            
        // Destroy detectors
        [detector trueRelease];
    }
    return layout;
}

2. DFS循环检测

// graphElement: 当前节点
// stackDepth：检测最长步数
- (NSSet<NSArray<FBObjectiveCGraphElement *> *> *)_findRetainCyclesInObject:(FBObjectiveCGraphElement *)graphElement stackDepth:(NSUInteger)stackDepth
{
  NSMutableSet<NSArray<FBObjectiveCGraphElement *> *> *retainCycles = [NSMutableSet new];
  FBNodeEnumerator *wrappedObject = [[FBNodeEnumerator alloc] initWithObject:graphElement];
 // 保存当前检测路径
  NSMutableArray<FBNodeEnumerator *> *stack = [NSMutableArray new];
  // 记录访问过的节点
  NSMutableSet<FBNodeEnumerator *> *objectsOnPath = [NSMutableSet new];
  // Let's start with the root
  [stack addObject:wrappedObject];
  
  while ([stack count] > 0) {
    @autoreleasepool {
    // 每次获取栈定元素
      FBNodeEnumerator *top = [stack lastObject];
      
      if (![objectsOnPath containsObject:top]) {
        if ([_objectSet containsObject:@([top.object objectAddress])]) {
          [stack removeLastObject];
          continue;
        }
        [_objectSet addObject:@([top.object objectAddress])];
      }
      [objectsOnPath addObject:top];
    // 获取候选节点
      FBNodeEnumerator *firstAdjacent = [top nextObject];
      if (firstAdjacent) {
        BOOL shouldPushToStack = NO;
        
        if ([objectsOnPath containsObject:firstAdjacent]) {
          // 如果访问过的路径中包含了次节点：检测到了循环引用
          NSUInteger index = [stack indexOfObject:firstAdjacent];
          NSInteger length = [stack count] - index;

          if (index == NSNotFound) {
            shouldPushToStack = YES;
          } else {
            NSRange cycleRange = NSMakeRange(index, length);
            NSMutableArray<FBNodeEnumerator *> *cycle = [[stack subarrayWithRange:cycleRange] mutableCopy];
            [cycle replaceObjectAtIndex:0 withObject:firstAdjacent];
            // 将循环引用信息经过处理添加到retainCycles
            [retainCycles addObject:[self _shiftToUnifiedCycle:[self _unwrapCycle:cycle]]];
          }
        } else {
          shouldPushToStack = YES;
        }

        if (shouldPushToStack) {
          if ([stack count] < stackDepth) {
            [stack addObject:firstAdjacent];
          }
        }
      } else {
        // 如果没有候选节点，弹出栈
        [stack removeLastObject];
        [objectsOnPath removeObject:top];
      }
    }
  }
  return retainCycles;
}