- (BOOL)shouldBatchFetchForTableNode:(ASTableNode *)tableNode {
  if (_weNeedMoreContent) {
    return YES;
  }
  return NO;
}

- (void)__enterHierarchy
{
  ASDisplayNodeAssertMainThread();
  //.......
  
  if (!_flags.isInHierarchy && !_flags.visibilityNotificationsDisabled && ![self __selfOrParentHasVisibilityNotificationsDisabled]) {
      //.......
      //更新状态
      [self willEnterHierarchy];
      //遍历节点调用节点的__enterHierarchy
      for (ASDisplayNode *subnode in self.subnodes) {
        [subnode __enterHierarchy];
      }
      //.......
    if (self.contents == nil) { //如果内容为空
      CALayer *layer = self.layer;
      [layer setNeedsDisplay]; //调用layer的setNeedsDisplay
      //如果有占位图则显示占位图
      if ([self _locked_shouldHavePlaceholderLayer]) {
        [CATransaction begin];
        [CATransaction setDisableActions:YES];
        //显示placeHolderLayer
        [self _locked_setupPlaceholderLayerIfNeeded];
        _placeholderLayer.opacity = 1.0;
        [CATransaction commit];
        //将placehHolderLayer添加到layer
        [layer addSublayer:_placeholderLayer];
      }
    }
  }
  [self didEnterHierarchy];
}

- (void)setNeedsDisplay
{
  //...........
  {
    //...........
    if (isRasterized == NO && shouldApply == NO) {
      // We can't release the lock before applying to pending state, or it may be flushed before it can be applied.
      [ASDisplayNodeGetPendingState(self) setNeedsDisplay];
    }
  }
  
  if (isRasterized) {
    ASPerformBlockOnMainThread(^{
      // The below operation must be performed on the main thread to ensure against an extremely rare deadlock, where a parent node
      // begins materializing the view / layer hierarchy (locking itself or a descendant) while this node walks up
      // the tree and requires locking that node to access .rasterizesSubtree.
      // For this reason, this method should be avoided when possible.  Use _hierarchyState & ASHierarchyStateRasterized.
      ASDisplayNodeAssertMainThread();
      ASDisplayNode *rasterizedContainerNode = self.supernode;
      while (rasterizedContainerNode) {
        if (rasterizedContainerNode.rasterizesSubtree) {
          break;
        }
        rasterizedContainerNode = rasterizedContainerNode.supernode;
      }
      //将根节点标记为dirty
      [rasterizedContainerNode setNeedsDisplay];
    });
  } else {
    if (shouldApply) {
      // If not rasterized, and the node is loaded (meaning we certainly have a view or layer), send a
      // message to the view/layer first. This is because __setNeedsDisplay calls as scheduleNodeForDisplay,
      // which may call -displayIfNeeded. We want to ensure the needsDisplay flag is set now, and then cleared.
      [viewOrLayer setNeedsDisplay];
    }
    [self __setNeedsDisplay];
  }
}

- (void)__setNeedsDisplay
{
  BOOL shouldScheduleForDisplay = NO;
  {
    MutexLocker l(__instanceLock__);
    BOOL nowDisplay = ASInterfaceStateIncludesDisplay(_interfaceState);
    // FIXME: This should not need to recursively display, so create a non-recursive variant.
    // The semantics of setNeedsDisplay (as defined by CALayer behavior) are not recursive.
    if (_layer != nil && !checkFlag(Synchronous) && nowDisplay && [self _implementsDisplay]) {
      shouldScheduleForDisplay = YES;
    }
  }
  
  if (shouldScheduleForDisplay) {
    [ASDisplayNode scheduleNodeForRecursiveDisplay:self];
  }
}

+ (void)scheduleNodeForRecursiveDisplay:(ASDisplayNode *)node
{
  static dispatch_once_t onceToken;
  static ASRunLoopQueue<ASDisplayNode *> *renderQueue;
  dispatch_once(&onceToken, ^{
    renderQueue = [[ASRunLoopQueue<ASDisplayNode *> alloc] initWithRunLoop:CFRunLoopGetMain()
                                                             retainObjects:NO
                                                                   handler:^(ASDisplayNode * _Nonnull dequeuedItem, BOOL isQueueDrained) {
      [dequeuedItem _recursivelyTriggerDisplayAndBlock:NO];
      if (isQueueDrained) {
        CFTimeInterval timestamp = CACurrentMediaTime();
        [[NSNotificationCenter defaultCenter] postNotificationName:ASRenderingEngineDidDisplayScheduledNodesNotification
                                                            object:nil
                                                          userInfo:@{ASRenderingEngineDidDisplayNodesScheduledBeforeTimestamp: @(timestamp)}];
      }
    }];
  });

  as_log_verbose(ASDisplayLog(), "%s %@", sel_getName(_cmd), node);
  [renderQueue enqueue:node];
}

- (void)display:(BOOL)asynchronously
{
  if (CGRectIsEmpty(self.bounds)) {
    _attemptedDisplayWhileZeroSized = YES;
  }
  [self.asyncDelegate displayAsyncLayer:self asynchronously:asynchronously];
}

- (void)registerAsMainRunloopObserver
{
  ASDisplayNodeAssertMainThread();
  static CFRunLoopObserverRef observer;
  CFRunLoopRef runLoop = CFRunLoopGetCurrent();
  CFOptionFlags activities = (kCFRunLoopBeforeWaiting | // before the run loop starts sleeping
                              kCFRunLoopExit);          // before exiting a runloop run

  observer = CFRunLoopObserverCreateWithHandler(NULL,        // allocator
                                                activities,  // activities
                                                YES,         // repeats
                                                INT_MAX,     // order after CA transaction commits
                                                ^(CFRunLoopObserverRef observer, CFRunLoopActivity activity) {
                                                  ASDisplayNodeCAssertMainThread();
                                                  //在进入runloop休眠之前或者切换runloop模式导致runloop退出的时候会调用commit
                                                  [self commit];
                                                });
  CFRunLoopAddObserver(runLoop, observer, kCFRunLoopCommonModes);
  CFRelease(observer);
}

- (void)displayAsyncLayer:(_ASDisplayLayer *)asyncLayer asynchronously:(BOOL)asynchronously
{
  ASDisplayNodeAssertMainThread();

  //......
  ///1. CancelBlock  displayBlock  completetionBlock 初始化
  //创建CancelBlock
  asdisplaynode_iscancelled_block_t isCancelledBlock = nil;
  if (asynchronously) {
    uint displaySentinelValue = ++_displaySentinel;
    __weak ASDisplayNode *weakSelf = self;
    isCancelledBlock = ^BOOL{
      __strong ASDisplayNode *self = weakSelf;
      return self == nil || (displaySentinelValue != self->_displaySentinel.load());
    };
  } else {
    isCancelledBlock = ^BOOL{
      return NO;
    };
  }

  // 创建displayBlock，这里会调用delegate display 或者draw方法来获取到UIImage内容
  asyncdisplaykit_async_transaction_operation_block_t displayBlock = [self _displayBlockWithAsynchronous:asynchronously
                                                                                        isCancelledBlock:isCancelledBlock
                                                                                             rasterizing:NO];
  //.........

  // 创建completionBlock：这个block会在当前异步事务完成后并完成渲染后在主线程被调用，或者在同步的情况下（asynchronously == NO）直接调用
  asyncdisplaykit_async_transaction_operation_completion_block_t completionBlock = ^(id<NSObject> value, BOOL canceled){
    ASDisplayNodeCAssertMainThread();
    if (!canceled && !isCancelledBlock()) { //是否被取消，同步的情况下isCancelledBlock始终为NO
      UIImage *image = (UIImage *)value; //value放置的是image
      BOOL stretchable = (NO == UIEdgeInsetsEqualToEdgeInsets(image.capInsets, UIEdgeInsetsZero)); //图像是否是可拉伸的
      if (stretchable) {
        ASDisplayNodeSetResizableContents(layer, image);
      } else {
        //不可拉伸的情况下直接将内容作为contents
        layer.contentsScale = self.contentsScale;
        layer.contents = (id)image.CGImage;
      }
      //............
    }
  };

  //............
  
  if (asynchronously) {
    // 异步渲染操作被包含在transaction中，transaction可以允许并行处理最终将结果以同步的方式应用到layer的contents属性中
    // Async rendering operations are contained by a transaction, which allows them to proceed and concurrently
    // while synchronizing the final application of the results to the layer's contents property (completionBlock).
    
    // 2. 我们先查看我们是否可以将自己添加到父类的transaction容器中
    // First, look to see if we are expected to join a parent's transaction container.
    CALayer *containerLayer = layer.asyncdisplaykit_parentTransactionContainer ? : layer;
    
    // 如果transaction没有存在那么这里将会实例化并将它添加到_ASAsyncTransactionGroup，它会在runloop结束或者即将进入休眠之前提交出去
    // In the case that a transaction does not yet exist (such as for an individual node outside of a container),
    // this call will allocate the transaction and add it to _ASAsyncTransactionGroup.
    // It will automatically commit the transaction at the end of the runloop.
    _ASAsyncTransaction *transaction = containerLayer.asyncdisplaykit_asyncTransaction;
    
    //3. 将displayBlock添加到transaction，transaction将会立即启动执行
    // Adding this displayBlock operation to the transaction will start it IMMEDIATELY.
    // The only function of the transaction commit is to gate the calling of the completionBlock.
    [transaction addOperationWithBlock:displayBlock priority:self.drawingPriority queue:[_ASDisplayLayer displayQueue] completion:completionBlock];
  } else {
    //同步的情况下直接通过displayBlock生成contents，并通过completionBlock设置到layer.content
    UIImage *contents = (UIImage *)displayBlock();
    completionBlock(contents, NO);
  }
},

asyncdisplaykit_async_transaction_operation_completion_block_t completionBlock = ^(id<NSObject> value, BOOL canceled){
  ASDisplayNodeCAssertMainThread();
  if (!canceled && !isCancelledBlock()) { //是否被取消，同步的情况下isCancelledBlock始终为NO
    UIImage *image = (UIImage *)value; //value放置的是image
    BOOL stretchable = (NO == UIEdgeInsetsEqualToEdgeInsets(image.capInsets, UIEdgeInsetsZero)); //图像是否是可拉伸的
    if (stretchable) {
      ASDisplayNodeSetResizableContents(layer, image);
    } else {
      //不可拉伸的情况下直接将内容作为contents
      layer.contentsScale = self.contentsScale;
      layer.contents = (id)image.CGImage;
    }
    //........
};

- (asyncdisplaykit_async_transaction_operation_block_t)_displayBlockWithAsynchronous:(BOOL)asynchronous
                                                                    isCancelledBlock:(asdisplaynode_iscancelled_block_t)isCancelledBlock
                                                                         rasterizing:(BOOL)rasterizing
{
  ASDisplayNodeAssertMainThread();
  asyncdisplaykit_async_transaction_operation_block_t displayBlock = nil;
  ASDisplayNodeFlags flags;
  
  __instanceLock__.lock();

  flags = _flags;
  
  // We always create a graphics context, unless a -display method is used, OR if we are a subnode drawing into a rasterized parent.
  //如果没有display方法或者正在将子节点绘制到栅格化的父类上的时候需要创建Context
  BOOL shouldCreateGraphicsContext = (flags.implementsImageDisplay == NO && rasterizing == NO);
  //子节点时候需要栅格化
  BOOL shouldBeginRasterizing = (rasterizing == NO && flags.rasterizesSubtree);
  //是否实现了display方法
  BOOL usesImageDisplay = flags.implementsImageDisplay;
  //是否实现了drawRect方法
  BOOL usesDrawRect = flags.implementsDrawRect;
  //如果没有实现display/drawRect方法并且子节点不需要栅格化直接返回
  if (usesImageDisplay == NO && usesDrawRect == NO && shouldBeginRasterizing == NO) {
    // Early exit before requesting more expensive properties like bounds and opaque from the layer.
    __instanceLock__.unlock();
    return nil;
  }
  
  BOOL opaque = self.opaque;
  CGRect bounds = self.bounds;
  UIColor *backgroundColor = self.backgroundColor;
  CGColorRef borderColor = self.borderColor;
  CGFloat borderWidth = self.borderWidth;
  CGFloat contentsScaleForDisplay = _contentsScaleForDisplay;
    
  __instanceLock__.unlock();

  // Capture drawParameters from delegate on main thread, if this node is displaying itself rather than recursively rasterizing.
  id drawParameters = (shouldBeginRasterizing == NO ? [self drawParameters] : nil);
  
  // Only the -display methods should be called if we can't size the graphics buffer to use.
  if (CGRectIsEmpty(bounds) && (shouldBeginRasterizing || shouldCreateGraphicsContext)) {
    return nil;
  }
  //..........
  //是否栅格化
  if (shouldBeginRasterizing) {
    // Collect displayBlocks for all descendants.
    // 用于放置子节点的displayBlock在父节点的displayBlock中直接遍历各个子节点的displayBlock
    NSMutableArray *displayBlocks = [[NSMutableArray alloc] init];
    [self _recursivelyRasterizeSelfAndSublayersWithIsCancelledBlock:isCancelledBlock displayBlocks:displayBlocks];
    CHECK_CANCELLED_AND_RETURN_NIL();

    opaque = opaque && CGColorGetAlpha(backgroundColor.CGColor) == 1.0f;

    //这里会将整个container的所有子节点的displayBlock打包给displayBlock，在执行container的displayBlock后会调用这些子节点的displayBlock将其绘制到container上
    displayBlock = ^id{
      CHECK_CANCELLED_AND_RETURN_NIL();
      UIImage *image = ASGraphicsCreateImageWithOptions(bounds.size, opaque, contentsScaleForDisplay, nil, isCancelledBlock, ^{
        for (dispatch_block_t block in displayBlocks) {
          if (isCancelledBlock()) return;
          block();
        }
      });

      ASDN_DELAY_FOR_DISPLAY();
      return image;
    };
  } else {
    
    displayBlock = ^id{
      
      CHECK_CANCELLED_AND_RETURN_NIL();

      __block UIImage *image = nil;
      void (^workWithContext)() = ^{
        CGContextRef currentContext = UIGraphicsGetCurrentContext();

        if (shouldCreateGraphicsContext && !currentContext) {
          ASDisplayNodeAssert(NO, @"Failed to create a CGContext (size: %@)", NSStringFromCGSize(bounds.size));
          return;
        }

        // For -display methods, we don't have a context, and thus will not call the _willDisplayNodeContentWithRenderingContext or
        // _didDisplayNodeContentWithRenderingContext blocks. It's up to the implementation of -display... to do what it needs.
        [self __willDisplayNodeContentWithRenderingContext:currentContext drawParameters:drawParameters];
        //根据情况调用display方法或者drawRect方法
        if (usesImageDisplay) {                                   // If we are using a display method, we'll get an image back directly.
          image = [self.class displayWithParameters:drawParameters isCancelled:isCancelledBlock];
        } else if (usesDrawRect) {                                // If we're using a draw method, this will operate on the currentContext.
          [self.class drawRect:bounds withParameters:drawParameters isCancelled:isCancelledBlock isRasterizing:rasterizing];
        }
        [self __didDisplayNodeContentWithRenderingContext:currentContext image:&image drawParameters:drawParameters backgroundColor:backgroundColor borderWidth:borderWidth borderColor:borderColor];
        ASDN_DELAY_FOR_DISPLAY();
      };

      if (shouldCreateGraphicsContext) {
        return ASGraphicsCreateImageWithOptions(bounds.size, opaque, contentsScaleForDisplay, nil, isCancelledBlock, workWithContext);
      } else {
        workWithContext();
        return image;
      }
    };
  }
  //...........
  return displayBlock;
}

- (void)_recursivelyRasterizeSelfAndSublayersWithIsCancelledBlock:(asdisplaynode_iscancelled_block_t)isCancelledBlock displayBlocks:(NSMutableArray *)displayBlocks
{
  // Skip subtrees that are hidden or zero alpha.
  if (self.isHidden || self.alpha <= 0.0) {
    return;
  }
  
  __instanceLock__.lock();
  BOOL rasterizingFromAscendent = (_hierarchyState & ASHierarchyStateRasterized);
  __instanceLock__.unlock();

  // if super node is rasterizing descendants, subnodes will not have had layout calls because they don't have layers
  if (rasterizingFromAscendent) {
    [self __layout];
  }

  // Capture these outside the display block so they are retained.
  UIColor *backgroundColor = self.backgroundColor;
  CGRect bounds = self.bounds;
  CGFloat cornerRadius = self.cornerRadius;
  BOOL clipsToBounds = self.clipsToBounds;

  CGRect frame;
  
  // If this is the root container node, use a frame with a zero origin to draw into. If not, calculate the correct frame using the node's position, transform and anchorPoint.
  if (self.rasterizesSubtree) {
    frame = CGRectMake(0.0f, 0.0f, bounds.size.width, bounds.size.height);
  } else {
    CGPoint position = self.position;
    CGPoint anchorPoint = self.anchorPoint;
    
    // Pretty hacky since full 3D transforms aren't actually supported, but attempt to compute the transformed frame of this node so that we can composite it into approximately the right spot.
    CGAffineTransform transform = CATransform3DGetAffineTransform(self.transform);
    CGSize scaledBoundsSize = CGSizeApplyAffineTransform(bounds.size, transform);
    CGPoint origin = CGPointMake(position.x - scaledBoundsSize.width * anchorPoint.x,
                                 position.y - scaledBoundsSize.height * anchorPoint.y);
    frame = CGRectMake(origin.x, origin.y, bounds.size.width, bounds.size.height);
  }

  // Get the display block for this node.
  asyncdisplaykit_async_transaction_operation_block_t displayBlock = [self _displayBlockWithAsynchronous:NO isCancelledBlock:isCancelledBlock rasterizing:YES];

  // We'll display something if there is a display block, clipping, translation and/or a background color.
  BOOL shouldDisplay = displayBlock || backgroundColor || CGPointEqualToPoint(CGPointZero, frame.origin) == NO || clipsToBounds;

  // If we should display, then push a transform, draw the background color, and draw the contents.
  // The transform is popped in a block added after the recursion into subnodes.
  if (shouldDisplay) {
    dispatch_block_t pushAndDisplayBlock = ^{
      // Push transform relative to parent.
      CGContextRef context = UIGraphicsGetCurrentContext();
      CGContextSaveGState(context);

      CGContextTranslateCTM(context, frame.origin.x, frame.origin.y);

      //support cornerRadius
      if (rasterizingFromAscendent && clipsToBounds) {
        if (cornerRadius) {
          [[UIBezierPath bezierPathWithRoundedRect:bounds cornerRadius:cornerRadius] addClip];
        } else {
          CGContextClipToRect(context, bounds);
        }
      }

      // Fill background if any.
      CGColorRef backgroundCGColor = backgroundColor.CGColor;
      if (backgroundColor && CGColorGetAlpha(backgroundCGColor) > 0.0) {
        CGContextSetFillColorWithColor(context, backgroundCGColor);
        CGContextFillRect(context, bounds);
      }

      // If there is a display block, call it to get the image, then copy the image into the current context (which is the rasterized container's backing store).
      if (displayBlock) {
        UIImage *image = (UIImage *)displayBlock();
        if (image) {
          BOOL opaque = ASImageAlphaInfoIsOpaque(CGImageGetAlphaInfo(image.CGImage));
          CGBlendMode blendMode = opaque ? kCGBlendModeCopy : kCGBlendModeNormal;
          [image drawInRect:bounds blendMode:blendMode alpha:1];
        }
      }
    };
    [displayBlocks addObject:pushAndDisplayBlock];
  }

  // Recursively capture displayBlocks for all descendants.
  for (ASDisplayNode *subnode in self.subnodes) {
    [subnode _recursivelyRasterizeSelfAndSublayersWithIsCancelledBlock:isCancelledBlock displayBlocks:displayBlocks];
  }

  // If we pushed a transform, pop it by adding a display block that does nothing other than that.
  if (shouldDisplay) {
    // Since this block is pure, we can store it statically.
    static dispatch_block_t popBlock;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
      popBlock = ^{
        CGContextRef context = UIGraphicsGetCurrentContext();
        CGContextRestoreGState(context);
      };
    });
    [displayBlocks addObject:popBlock];
  }
}

- (asyncdisplaykit_async_transaction_operation_block_t)_displayBlockWithAsynchronous:(BOOL)asynchronous
                                                                    isCancelledBlock:(asdisplaynode_iscancelled_block_t)isCancelledBlock
                                                                         rasterizing:(BOOL)rasterizing
{
  ASDisplayNodeAssertMainThread();
  //........
  //是否实现了display方法
  BOOL usesImageDisplay = flags.implementsImageDisplay;
  //是否实现了drawRect方法
  BOOL usesDrawRect = flags.implementsDrawRect;
  //..........
  //是否栅格化
  if (shouldBeginRasterizing) {
      //.......
  } else {
    displayBlock = ^id{
      __block UIImage *image = nil;
      void (^workWithContext)() = ^{
        CGContextRef currentContext = UIGraphicsGetCurrentContext();
        // .......
        // For -display methods, we don't have a context, and thus will not call the _willDisplayNodeContentWithRenderingContext or
        // _didDisplayNodeContentWithRenderingContext blocks. It's up to the implementation of -display... to do what it needs.
        [self __willDisplayNodeContentWithRenderingContext:currentContext drawParameters:drawParameters];
        //根据情况调用display方法或者drawRect方法
        if (usesImageDisplay) {                                   // If we are using a display method, we'll get an image back directly.
          image = [self.class displayWithParameters:drawParameters isCancelled:isCancelledBlock];
        } else if (usesDrawRect) {                                // If we're using a draw method, this will operate on the currentContext.
          [self.class drawRect:bounds withParameters:drawParameters isCancelled:isCancelledBlock isRasterizing:rasterizing];
        }
        [self __didDisplayNodeContentWithRenderingContext:currentContext image:&image drawParameters:drawParameters backgroundColor:backgroundColor borderWidth:borderWidth borderColor:borderColor];
        ASDN_DELAY_FOR_DISPLAY();
      };

      if (shouldCreateGraphicsContext) {
        return ASGraphicsCreateImageWithOptions(bounds.size, opaque, contentsScaleForDisplay, nil, isCancelledBlock, workWithContext);
      } else {
        workWithContext();
        return image;
      }
    };
  }
  //...........
  return displayBlock;
}

@interface ASLayout : NSObject

/**
 * 当前布局对象
 */
@property (nonatomic, weak, readonly) id<ASLayoutElement> layoutElement;

/**
 * 节点类型
 */
@property (nonatomic, readonly) ASLayoutElementType type;

/**
 * 当前布局的Size
 */
@property (nonatomic, readonly) CGSize size;

/**
 * 在父节点的位置
 */
@property (nonatomic, readonly) CGPoint position;

/**
 * 子节点的布局
 */
@property (nonatomic, copy, readonly) NSArray<ASLayout *> *sublayouts;

/**
 * 某个节点的位置
 */
- (CGRect)frameForElement:(id<ASLayoutElement>)layoutElement;

/**
 * 根据postion和size计算出来的frame
 */
@property (nonatomic, readonly) CGRect frame;

//......

/**
 * Traverses the existing layout tree and generates a new tree that represents only ASDisplayNode layouts
 */
- (ASLayout *)filteredNodeLayoutTree NS_RETURNS_RETAINED AS_WARN_UNUSED_RESULT;

@end

- (ASLayout *)calculateLayoutThatFits:(ASSizeRange)constrainedSize
{
  //调用方法之前的检查，必须提供layoutSpecBlock或者重写calculateLayoutThatFits，calculateSizeThatFits或者layoutSpecThatFits
  __ASDisplayNodeCheckForLayoutMethodOverrides;

  //根据不同布局引擎类型实现不同的布局
  switch (self.layoutEngineType) {
    //使用布局规范引擎
    case ASLayoutEngineTypeLayoutSpec:
      return [self calculateLayoutLayoutSpec:constrainedSize];
#if YOGA
    //使用YOGA布局引擎
    case ASLayoutEngineTypeYoga:
      return [self calculateLayoutYoga:constrainedSize];
#endif
    default:
      break;
  }
  return nil;
}

- (void)_layoutSublayouts
{
  ASDisplayNodeAssertThreadAffinity(self);
  //............
  for (ASDisplayNode *node in self.subnodes) {
    CGRect frame = [layout frameForElement:node];
    if (CGRectIsNull(frame)) {
      // There is no frame for this node in our layout.
      // This currently can happen if we get a CA layout pass
      // while waiting for the client to run animateLayoutTransition:
    } else {
      node.frame = frame;
    }
  }
}

- (void)__layout
{
  //......
  BOOL loaded = NO;
  {
    //........
    // This method will confirm that the layout is up to date (and update if needed).
    // Importantly, it will also APPLY the layout to all of our subnodes if (unless parent is transitioning).
    l.unlock();
    // 如果过期了就会重新计算，否则使用缓存的布局
    [self _u_measureNodeWithBoundsIfNecessary:bounds];
    l.lock();
    //布局占位图
    [self _locked_layoutPlaceholderIfNecessary];
  }
  //调用_layoutSublayouts
  [self _layoutSublayouts];
  
  if (loaded) {
    ASPerformBlockOnMainThread(^{
      [self layout];
      [self _layoutClipCornersIfNeeded];
      [self _layoutDidFinish];
    });
  }
  [self _fallbackUpdateSafeAreaOnChildren];
}

/**
 显示在label上的文本，它和attributedText是互斥的，一旦设置了attributedText 就会覆盖 text
 */
@property (nullable, nonatomic, copy) NSString *text;

/**
 text的文本字体，也会影响到attributedText
 */
@property (null_resettable, nonatomic, strong) UIFont *font;

/**
 text的颜色，默认是黑色，这个值的设置也会影响到attributedText
 */
@property (null_resettable, nonatomic, strong) UIColor *textColor;

/**
 text文本阴影的颜色，这个值的设置也会影响到attributedText
 */
@property (nullable, nonatomic, strong) UIColor *shadowColor;

/**
 阴影的偏移，默认是CGSizeZero，这个值的设置也会影响到attributedText
 */
@property (nonatomic) CGSize shadowOffset;

/**
 text 阴影模糊半径，默认为0，这个值的设置也会影响到attributedText
 */
@property (nonatomic) CGFloat shadowBlurRadius;

/**
 text的对齐方式
 */
@property (nonatomic) NSTextAlignment textAlignment;

/**
 垂直对齐方式
 */
@property (nonatomic) YYTextVerticalAlignment textVerticalAlignment;

/**
  属性文本内容
 */
@property (nullable, nonatomic, copy) NSAttributedString *attributedText;

/**
 断行模式
 */
@property (nonatomic) NSLineBreakMode lineBreakMode;

/**
 在文本被截断的时候，作为截断文本的字符串，默认为“...”
 */
@property (nullable, nonatomic, copy) NSAttributedString *truncationToken;

/**
  最大文本行数
 */
@property (nonatomic) NSUInteger numberOfLines;

/**
 多行文本的推荐宽度，如果文本的宽度超过这个设定值，文本内容将会显示到新的一行或者多行，所以会增加整个文本的高度。
 */
@property (nonatomic) CGFloat preferredMaxLayoutWidth;


/**
 可以点击的修饰样式

 UIDataDetectorTypePhoneNumber              手机号码
 UIDataDetectorTypeLink                     URL链接
 UIDataDetectorTypeAddress                  地址
 UIDataDetectorTypeCalendarEvent            日历事件
 UIDataDetectorTypeShipmentTrackingNumber  船舶跟踪号码
 UIDataDetectorTypeFlightNumber            航空号码
 UIDataDetectorTypeLookupSuggestion        用户查询建议
 UIDataDetectorTypeNone                    无修饰样式
 UIDataDetectorTypeAll                     全部样式
 */
@property (nonatomic) UIDataDetectorTypes dataDetectorTypes;

/**
 * 用于修改dataDetectorTypes的样式
 */
@property (nullable, nonatomic, copy) NSDictionary<NSString *, id> *linkTextAttributes;


/**
 * 高亮文本样式
 */
@property (nullable, nonatomic, copy) NSDictionary<NSString *, id> *highlightTextAttributes;

/**
 * 用户新输入的文本属性
 */
@property (nullable, nonatomic, copy) NSDictionary<NSString *, id> *typingAttributes;

/**
  占位文本
 */
@property (nullable, nonatomic, copy) NSString *placeholderText;

/**
 占位文本字体
 */
@property (nullable, nonatomic, strong) UIFont *placeholderFont;

/**
 占位文本颜色
 */
@property (nullable, nonatomic, strong) UIColor *placeholderTextColor;

/**
 占位文本富文本属性
 */
@property (nullable, nonatomic, copy) NSAttributedString *placeholderAttributedText;


/**
 当前选择的Range
 */
@property (nonatomic) NSRange selectedRange;

/**
 * 插入的文本是否替换旧有的内容
 */
@property (nonatomic) BOOL clearsOnInsertion;

/**
 能否选择文本，编辑文本
 */
@property (nonatomic, getter=isSelectable) BOOL selectable;

/**
 是否可以高亮文本
 */
@property (nonatomic, getter=isHighlightable) BOOL highlightable;

/**
 是否可编辑
 */
@property (nonatomic, getter=isEditable) BOOL editable;

/**
 是否允许粘贴图片
 */
@property (nonatomic) BOOL allowsPasteImage;

/**
 是否允许粘贴富文本
 */
@property (nonatomic) BOOL allowsPasteAttributedString;

/**
 是否允许复制富文本
 */
@property (nonatomic) BOOL allowsCopyAttributedString;

/**
是否允许重做和撤销
 */
@property (nonatomic) BOOL allowsUndoAndRedo;

/**
 撤销步骤数
 */
@property (nonatomic) NSUInteger maximumUndoLevel;


/**
 * 在textview获得焦点的时候取代系统键盘的自定义输入view
 */
@property (nullable, nonatomic, readwrite, strong) __kindof UIView *inputView;

/**
 * 
 * 在textview获得焦点的时候显示在键盘上方的附加view
 */
@property (nullable, nonatomic, readwrite, strong) __kindof UIView *inputAccessoryView;

/**
 * 如果不使用inputAccessoryView属性指定自定义附加view，可以使用它来指定附加view的高度
 */
@property (nonatomic) CGFloat extraAccessoryViewHeight;

/**
 点击文本的时候响应Block
 */
@property (nullable, nonatomic, copy) YYTextAction textTapAction;
/**
 长按文本的时候响应的Block
 */
@property (nullable, nonatomic, copy) YYTextAction textLongPressAction;
/**
 * 点击高亮文本的时候执行的动作
 */
@property (nullable, nonatomic, copy) YYTextAction highlightTapAction;
/**
 * 长按高亮文本时候执行的动作
 */
@property (nullable, nonatomic, copy) YYTextAction highlightLongPressAction;

/**
 文本内间距
 */
@property (nonatomic) UIEdgeInsets textContainerInset;

/**
 用于控制布局和渲染代码是否运行在后台线程，默认是不运行在后台线程
 */
@property (nonatomic) BOOL displaysAsynchronously;

/**
 当异步显示打开的情况下，在后台渲染进程结束后，layer的内容将会更新，但是如果渲染进程在一个垂直同步时间内
 不能完成渲染工作，将会保持显示显示旧的内容。我们可以在更新label属性后通过手动将layer.contents设置为nil，或者将这个值设置为YES.

 */
@property (nonatomic) BOOL clearContentsBeforeAsynchronouslyDisplay;

/**
 在文本内容发生改变的时候会有一个动画
 */
@property (nonatomic) BOOL fadeOnAsynchronouslyDisplay;

/**
在某些文本高亮的时候呈现一个动画
 */
@property (nonatomic) BOOL fadeOnHighlight;

/**
 忽略text, font, textColor, attributedText...这些通用的属性，只使用textLayout来显示文本内容
 */
@property (nonatomic) BOOL ignoreCommonProperties;

/**
 设置全部文本的样式
 */
- (void)yy_setAttribute:(NSString *)name value:(nullable id)value;

/**
 设置指定范围的文本样式
 */
- (void)yy_setAttribute:(NSString *)name value:(nullable id)value range:(NSRange)range;

/**
 The font of the text.
 */
@property (nullable, nonatomic, strong, readwrite) UIFont *yy_font;
- (void)yy_setFont:(nullable UIFont *)font range:(NSRange)range;

/**
 The foreground color.
 */
@property (nullable, nonatomic, strong, readwrite) UIColor *yy_color;
- (void)yy_setColor:(nullable UIColor *)color range:(NSRange)range;

/**
 The background color.
 */
@property (nullable, nonatomic, strong, readwrite) UIColor *yy_backgroundColor;
- (void)yy_setBackgroundColor:(nullable UIColor *)backgroundColor range:(NSRange)range;

/**
 The stroke width.
 */
@property (nullable, nonatomic, strong, readwrite) NSNumber *yy_strokeWidth;
- (void)yy_setStrokeWidth:(nullable NSNumber *)strokeWidth range:(NSRange)range;

/**
 The stroke color.
 */
@property (nullable, nonatomic, strong, readwrite) UIColor *yy_strokeColor;
- (void)yy_setStrokeColor:(nullable UIColor *)strokeColor range:(NSRange)range;

/**
 The text shadow.
 */
@property (nullable, nonatomic, strong, readwrite) NSShadow *yy_shadow;
- (void)yy_setShadow:(nullable NSShadow *)shadow range:(NSRange)range;

/**
 The strikethrough style.
 */
@property (nonatomic, readwrite) NSUnderlineStyle yy_strikethroughStyle;
- (void)yy_setStrikethroughStyle:(NSUnderlineStyle)strikethroughStyle range:(NSRange)range;

/**
 The strikethrough color.
 */
@property (nullable, nonatomic, strong, readwrite) UIColor *yy_strikethroughColor;
- (void)yy_setStrikethroughColor:(nullable UIColor *)strikethroughColor range:(NSRange)range NS_AVAILABLE_IOS(7_0);

/**
 The underline style.
 */
@property (nonatomic, readwrite) NSUnderlineStyle yy_underlineStyle;
- (void)yy_setUnderlineStyle:(NSUnderlineStyle)underlineStyle range:(NSRange)range;

/**
 The underline color.
 */
@property (nullable, nonatomic, strong, readwrite) UIColor *yy_underlineColor;
- (void)yy_setUnderlineColor:(nullable UIColor *)underlineColor range:(NSRange)range;

/**
 An NSParagraphStyle object which is used to specify things like
 line alignment, tab rulers, writing direction, etc.
 */
@property (nullable, nonatomic, strong, readwrite) NSParagraphStyle *yy_paragraphStyle;
- (void)yy_setParagraphStyle:(nullable NSParagraphStyle *)paragraphStyle range:(NSRange)range;

/**
 * 文本对齐方式
 */
@property (nonatomic, readwrite) NSTextAlignment yy_alignment;
- (void)yy_setAlignment:(NSTextAlignment)alignment range:(NSRange)range;

/**
 * 断行模式
 */
@property (nonatomic, readwrite) NSLineBreakMode yy_lineBreakMode;
- (void)yy_setLineBreakMode:(NSLineBreakMode)lineBreakMode range:(NSRange)range;

/**
 行间距
 */
@property (nonatomic, readwrite) CGFloat yy_lineSpacing;
- (void)yy_setLineSpacing:(CGFloat)lineSpacing range:(NSRange)range;

/**
 段落间距
 */
@property (nonatomic, readwrite) CGFloat yy_paragraphSpacing;
- (void)yy_setParagraphSpacing:(CGFloat)paragraphSpacing range:(NSRange)range;

/**
 段落前间距
 */
@property (nonatomic, readwrite) CGFloat yy_paragraphSpacingBefore;
- (void)yy_setParagraphSpacingBefore:(CGFloat)paragraphSpacingBefore range:(NSRange)range;

/**
  首行间距
 */
@property (nonatomic, readwrite) CGFloat yy_firstLineHeadIndent;
- (void)yy_setFirstLineHeadIndent:(CGFloat)firstLineHeadIndent range:(NSRange)range;

/**
 最小高度
 */
@property (nonatomic, readwrite) CGFloat yy_minimumLineHeight;
- (void)yy_setMinimumLineHeight:(CGFloat)minimumLineHeight range:(NSRange)range;

/**
 最大高度
 */
@property (nonatomic, readwrite) CGFloat yy_maximumLineHeight;
- (void)yy_setMaximumLineHeight:(CGFloat)maximumLineHeight range:(NSRange)range;

/**
 Convenience method to set text highlight
 @param range           text range
 @param color           text color (pass nil to ignore)
 @param backgroundColor text background color when highlight
 @param userInfo        user information dictionary (pass nil to ignore)
 @param tapAction       tap action when user tap the highlight (pass nil to ignore)
 @param longPressAction long press action when user long press the highlight (pass nil to ignore)
 */
- (void)yy_setTextHighlightRange:(NSRange)range
                           color:(nullable UIColor *)color
                 backgroundColor:(nullable UIColor *)backgroundColor
                        userInfo:(nullable NSDictionary *)userInfo
                       tapAction:(nullable YYTextAction)tapAction
                 longPressAction:(nullable YYTextAction)longPressAction;

@interface YYTextBorder : NSObject <NSCoding, NSCopying>
+ (instancetype)borderWithLineStyle:(YYTextLineStyle)lineStyle lineWidth:(CGFloat)width strokeColor:(nullable UIColor *)color;
+ (instancetype)borderWithFillColor:(nullable UIColor *)color cornerRadius:(CGFloat)cornerRadius;
@property (nonatomic) YYTextLineStyle lineStyle;              ///< border line style
@property (nonatomic) CGFloat strokeWidth;                    ///< border line width
@property (nullable, nonatomic, strong) UIColor *strokeColor; ///< border line color
@property (nonatomic) CGLineJoin lineJoin;                    ///< border line join
@property (nonatomic) UIEdgeInsets insets;                    ///< border insets for text bounds
@property (nonatomic) CGFloat cornerRadius;                   ///< border corder radius
@property (nullable, nonatomic, strong) YYTextShadow *shadow; ///< border shadow
@property (nullable, nonatomic, strong) UIColor *fillColor;   ///< inner fill color
@end

/// Creates a container with the specified size and insets. @param size The size. @param insets The text insets.
+ (instancetype)containerWithSize:(CGSize)size insets:(UIEdgeInsets)insets;

/// Creates a container with the specified path. @param size The path.
+ (instancetype)containerWithPath:(nullable UIBezierPath *)path;

///< Bounding rect (glyphs)
@property (nonatomic, readonly) CGRect textBoundingRect;
///< Bounding size (glyphs and insets, ceil to pixel)
@property (nonatomic, readonly) CGSize textBoundingSize;
///< Number of rows
@property (nonatomic, readonly) NSUInteger rowCount;

YYLabel *label = [YYLabel new];
label.displaysAsynchronously = YES;
label.ignoreCommonProperties = YES;
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    // Create attributed string.
    NSMutableAttributedString *text = [[NSMutableAttributedString alloc] initWithString:@"Some Text"];
    text.yy_font = [UIFont systemFontOfSize:16];
    text.yy_color = [UIColor grayColor];
    [text yy_setColor:[UIColor redColor] range:NSMakeRange(0, 4)];
    // Create text container
    YYTextContainer *container = [YYTextContainer new];
    container.size = CGSizeMake(100, CGFLOAT_MAX);
    container.maximumNumberOfRows = 0;
    // Generate a text layout.
    YYTextLayout *layout = [YYTextLayout layoutWithContainer:container text:text];
    dispatch_async(dispatch_get_main_queue(), ^{
        label.size = layout.textBoundingSize;
        label.textLayout = layout;
    });
});

/**
 当文本改变的时候会调用这个方法
 @param text  最初的富文本，这个方法会解析这个文本，并且修改它的内容
 @param selectedRange  当前选择的文本内容
 如果文本修改了就返回YES,如果没有修改则返回NO
 */
- (BOOL)parseText:(nullable NSMutableAttributedString *)text selectedRange:(nullable NSRangePointer)selectedRange;

NSMutableAttributedString *one = [[NSMutableAttributedString alloc] initWithString:@"Shadow"];
one.yy_font = [UIFont boldSystemFontOfSize:30];
one.yy_color = [UIColor whiteColor];
YYTextShadow *shadow = [YYTextShadow new];
shadow.color = [UIColor colorWithWhite:0.000 alpha:0.490];
shadow.offset = CGSizeMake(0, 1);
shadow.radius = 5;
one.yy_textShadow = shadow;

NSMutableAttributedString *one = [[NSMutableAttributedString alloc] initWithString:@"Inner Shadow"];
one.yy_font = [UIFont boldSystemFontOfSize:30];
one.yy_color = [UIColor whiteColor];
YYTextShadow *shadow = [YYTextShadow new];
shadow.color = [UIColor colorWithWhite:0.000 alpha:0.40];
shadow.offset = CGSizeMake(0, 1);
shadow.radius = 1;
one.yy_textInnerShadow = shadow;

@property (nullable, nonatomic, strong) UIColor *baselineColor;      ///< baseline color
@property (nullable, nonatomic, strong) UIColor *CTFrameBorderColor; ///< CTFrame path border color
@property (nullable, nonatomic, strong) UIColor *CTFrameFillColor;   ///< CTFrame path fill color
@property (nullable, nonatomic, strong) UIColor *CTLineBorderColor;  ///< CTLine bounds border color
@property (nullable, nonatomic, strong) UIColor *CTLineFillColor;    ///< CTLine bounds fill color
@property (nullable, nonatomic, strong) UIColor *CTLineNumberColor;  ///< CTLine line number color
@property (nullable, nonatomic, strong) UIColor *CTRunBorderColor;   ///< CTRun bounds border color
@property (nullable, nonatomic, strong) UIColor *CTRunFillColor;     ///< CTRun bounds fill color
@property (nullable, nonatomic, strong) UIColor *CTRunNumberColor;   ///< CTRun number color
@property (nullable, nonatomic, strong) UIColor *CGGlyphBorderColor; ///< CGGlyph bounds border color
@property (nullable, nonatomic, strong) UIColor *CGGlyphFillColor;   ///< CGGlyph bounds fill color