AsyncDisplayKit源码阅读之ASLocking

首先，协议中定义了一个方法，不通过block来进行加锁操作

/// Try to take lock without blocking. Returns whether the lock was taken.
- (BOOL)tryLock;

关键数据结构，一个最多包含kLockSetCapacity把锁的数组，这里用的是普通结构体类型，需要手动释放内存。

/**
 * A set of locks acquired during ASLockSequence.
 */
typedef struct {
  unsigned count;
  CFTypeRef _Nullable locks[kLockSetCapacity];
} ASLockSet;

这里通过__unused定义，避免了警告，在不使用时不会编译
通过__attribute__((cleanup(ASUnlockSet))，可以在其离开作用域之后自动执行ASUnlockSet这个方法

/**
 * Declare a lock set that is automatically unlocked at the end of scope.
 *
 * We use this instead of a scope-locking macro because we want to be able
 * to step through the lock sequence block in the debugger.
 */
#define ASScopedLockSet __unused ASLockSet __attribute__((cleanup(ASUnlockSet)))

向集合中添加一个锁的方法，返回添加成功与否

/**
 * A block that attempts to add a lock to a lock sequence.
 * Such a block is provided to the caller of ASLockSequence.
 *
 * Returns whether the lock was added. You should return
 * NO from your lock sequence body if it returns NO.
 *
 * For instance, you might write `return addLock(l1) && addLock(l2)`.
 *
 * @param lock The lock to attempt to add.
 * @return YES if the lock was added, NO otherwise.
 */
typedef BOOL(^ASAddLockBlock)(id<ASLocking> lock);

用于添加多个锁进入锁队列，例如将一个队列操作的锁的block，逐个调用方法，当且仅当所有锁添加成功，才返回YES。
此处用了NS_NOESCAPE逃逸标志，代表这个ASAddLockBlock会在ASLockSequenceBlock返回之前就执行完毕

/**
 * A block that attempts to lock multiple locks in sequence.
 * Such a block is provided by the caller of ASLockSequence.
 *
 * The block may be run multiple times, if not all locks are immediately
 * available. Therefore the block should be idempotent.
 *
 * The block should attempt to invoke addLock multiple times with
 * different locks. It should return NO as soon as any addLock
 * operation fails.
 *
 * For instance, you might write `return addLock(l1) && addLock(l2)`.
 *
 * @param addLock A block you can call to attempt to add a lock.
 * @return YES if all locks were added, NO otherwise.
 */
typedef BOOL(^ASLockSequenceBlock)(NS_NOESCAPE ASAddLockBlock addLock);

解除并且释放队列所有的锁，此处用了NS_INLINE，内联块，在别处调用此方法时会直接拷贝代码到相应位置，可以加快运行速度，但是换来的是内存上的增长。

/**
 * Unlock and release all of the locks in this lock set.
 */
NS_INLINE void ASUnlockSet(ASLockSet *lockSet) {
  for (unsigned i = 0; i < lockSet->count; i++) {
    CFTypeRef lock = lockSet->locks[i];
    [(__bridge id<ASLocking>)lock unlock];
    CFRelease(lock);
  }
}

用于加锁的函数，需要提供一个包含一系列锁的body，超过数量限制会失败，并且撤回加锁操作，执行sched_yield()让出资源给其他等于或大于当前优先级的线程执行任务，继续while，直到成功加锁。

/**
 * Take multiple locks "simultaneously," avoiding deadlocks
 * caused by lock ordering.
 *
 * The block you provide should attempt to take a series of locks,
 * using the provided `addLock` block. As soon as any addLock fails,
 * you should return NO.
 *
 * For example:
 * ASLockSequence(^(ASAddLockBlock addLock) ^{
 *   return addLock(l0) && addLock(l1);
 * });
 *
 * Note: This function doesn't protect from lock ordering deadlocks if
 * one of the locks is already locked (recursive.) Only locks taken
 * inside this function are guaranteed not to cause a deadlock.
 */
NS_INLINE ASLockSet ASLockSequence(NS_NOESCAPE ASLockSequenceBlock body)
{
  __block ASLockSet locks = (ASLockSet){0, {}};
  BOOL (^addLock)(id<ASLocking>) = ^(id<ASLocking> obj) {
    
    // nil lock = ignore.
    if (!obj) {
      return YES;
    }
    
    // If they go over capacity, assert and return YES.
    // If we return NO, they will enter an infinite loop.
    if (locks.count == kLockSetCapacity) {
      ASDisplayNodeCFailAssert(@"Locking more than %d locks at once is not supported.", kLockSetCapacity);
      return YES;
    }
    
    if ([obj tryLock]) {
      locks.locks[locks.count++] = (__bridge_retained CFTypeRef)obj;
      return YES;
    }
    return NO;
  };
  
  /**
   * Repeatedly try running their block, passing in our `addLock`
   * until it succeeds. If it fails, unlock all and yield the thread
   * to reduce spinning.
   */
  while (true) {
    if (body(addLock)) {
      // Success
      return locks;
    } else {
      ASUnlockSet(&locks);
      locks.count = 0;
      sched_yield();
    }
  }
}

/**
 * These Foundation classes already implement -tryLock.
 */

@interface NSLock (ASLocking) <ASLocking>
@end

@interface NSRecursiveLock (ASLocking) <ASLocking>
@end

@interface NSConditionLock (ASLocking) <ASLocking>
@end