iOS RunLoop 详解

转自 iOS RunLoop 详解

image.png

Runloop 是和线程紧密相关的基础组件，是很多多线程有关功能的幕后功臣。尽管在平常使用中几乎不会太直接用到，理解 Runloop 有利于我们更加深入的理解 iOS 的多线程模型。

本文从如下几个方面理解RunLoop的相关知识点。

RunLoop 概念
RunLoop 实现
RunLoop 运用
RunLoop 应用

RunLoop 概念

RunLoop 介绍

RunLoop 是什么？RunLoop 还是比较顾名思义的一个东西，说白了就是一种循环，只不过它这种循环比较高级。一般的 while 循环会导致 CPU 进入忙状态，而 RunLoop 则是一种“闲”等待，这部分可以类比 Linux 下的 epoll。当没有事件时，RunLoop 会进入休眠状态，有事件发生时，RunLoop 会去找相应的 Hander 处理事件。RunLoop 可以让线程需要做事的时候忙起来，不需要的话就让线程休眠。

从代码上看，RunLoop 其实就是一个对象，它的结构如下，源码看这里：

struct __CFRunLoop {
  CFRuntimeBase _base;
  pthread_mutex_t _lock; /* locked for accessing mode list */
  __CFPort _wakeUpPort; // used for CFRunLoopWakeUp 内核向该端口发送消息可以唤醒 RunLoop
  Boolean _unused;
  volatile _per_run_data *_perRunData; // reset for runs of the run loop
  pthread_t _pthread; // RunLoop 对应的线程
  uint32_t _winthread;
  CFMutableSetRef _commonModes; // 存储的是字符串，记录所有标记为 common 的 mode
  CGMutableSetRef _commonModeItems; // 存储所有 commonMode 的 item(source、timer、observer)
  CFRunLoopModeRef _currentMode; // 当前运行的 mode
  CFMutableSetRef _modes; // 存储的是 CFRunLoopModeRef
  struct _block_item *_blocks_head; // doblocks 的时候用到
  struct _block_item *_blocks_tail;
  CGTypeRef _counterpart;
}

可见，一个 RunLoop 对象，主要包含了一个线程，若干个 Mode，若干个 commonMode，还有一个当前运行的 Mode。

RunLoop 与线程

当我们需要一个常驻线程，可以让线程需要做事的时候忙起来，不需要的话就让线程休眠。我们就在线程里面执行下面这个代码，一直等待消息，线程就不会退出了。

do {
  // 获取消息
  // 处理消息
} while (消息 != 退出)

上面的这种循环模型被称作 Event Loop，事件循环模型在众多系统里都有实现，RunLoop 实际上就是一个对象，这个对象管理了其需要处理的事件和消息，并提供了一个入口函数来执行上面 Event Loop 的逻辑。线程执行了这个函数后，就会一直处于函数内部“接收消息->等待->处理”的循环中，直到这个循环结束（比如传入 quit 的消息），函数返回。

下图描述了Runloop运行流程（基本描述了上面Runloop的核心流程，当然可以查看官方The Run Loop Sequence of Events描述）：

runLoopFCD.jpg

整个流程并不复杂（需要注意的就是黄色区域的消息处理中并不包含source0，因为它在循环开始之初就会处理），整个流程其实就是一种Event Loop的实现，其他平台均有类似的实现，只是这里叫做RunLoop。

RunLoop与线程的关系如下图

image.png

图中展现了 RunLoop 在线程中的作用：从 input source 和 timer source 接受事件，然后在线程中处理事件。

RunLoop 和线程是绑定在一起的。每个线程（包括主线程）都有一个对应的 RunLoop 对象。我们并不能自己创建 RunLoop 对象，但是可以获取到系统提供的 RunLoop 对象。

主线程的 RunLoop 会在应用启动的时候完成启动，其他线程的 RunLoop 默认并不会启动，需要我们手动启动。

RunLoop Mode

Mode 可以视为事件的管家，一个 Mode 管理着各种事件，它的结构如下：

struct __CFRunLoopMode {
  CFRuntimeBase _base;
  pthread_mutex_t _lock; /* must have the run loop locked before locking this */
  CFStringRef _name; // mode 名称
  Boolean _stopped; // mode 是否被终止
  char _padding[3];
  // 几种事件
  CFMutableSetRef _sources0; // source0
  CFMutableSetRef _sources1: // sources1
  CFMutableArrayRef _observers; // 通知
  CFMutableArrayRef _times; // 定时器
  CFMutableDictionaryRef _portToV1SourceMap; // 字典 key 是 mach_port_t，value 是 CFRunLoopSourceRef
  __CFPortSet _portSet; // 保存所有需要监听的 port，比如 _weakUpPort, _timerPort 都保存在这个数据中
  CFIndex _observerMask;
#if USE_DISPATCH_SOURCE_FOR_TIMERS
  dispatch_source_t _timerSource;
  dispatch_queue_t _queue;
  Boolean _timerFired; // set to true by the source when a timer has fired
  Boolean _dispatchTimerArmed;
#endif
#if DEPLOYMENAT_TARGET_WINDOWS
  DWORD _msgQMask;
  void (* _msgPump)(void);
#endif
  uint64_t _timerSoftDeadline;
  uint64_t _timerHardDeadline;
}

一个 CFRunLoopMode 对象有一个 name，若干 source0、 source1、timer、observer 和若干 port，可见事件都是由 Mode 在管理，而 RunLoop 管理 Mode。

从源码很容易看出，RunLoop 总是运行在某种特定的 CFRunLoopModeRef 下（每次运行 __CFRunLoopRun() 函数时必须指定 Mode）。而通过 CFRunLoopRef 对应结构体的定义可以很容易知道每种 RunLoop 都可以包含个 Mode，每个 Mode 有包含 Source/Timer/Observer。每次调用 RunLoop 的主函数 __CFRunLoopRun() 时必须指定一种 Mode，这个 Mode 称为 _curentMode，当切换 Mode 时必须退出当前 Mode，然后重新进入 RunLoop 以保证不同 Mode 的 Source/Timer/Observer 互不影响。

image.png

如图所示，RunLoop Mode 实际上是 Source，Timer 和 Observer 的集合，不同的 Mode 把不同组的 Source，Timer 和 Observer 隔绝开来。RunLoop 在某个时刻只能跑在一个 Mode 下，处理这一个 Mode 当中的 Source，Timer 和 Observer。

苹果文档中提到的 Mode 有五个，分别是：

NSDefaultRunLoopMode
NSConnectionReplyMode
NSModalPanelRunLoopMode
NSEventTrackingRunLoopMode
NSRunLoopCommonModes

iOS 中公开暴露出来的只有 NSDefaultRunLoopMode 和 NSRunLoopCommonModes。NSRunLoopCommonModes 实际上是一个 Mode 的集合，默认包括 NSDefaultRunLoopMode 和 NSEventTrackingRunLoopMode（注意：并不是说 RunLoop 会运行在 kCFRunLoopCommonModes 这种模式下，而是相当于分别注册了 NSDefaultRunLoopMode 和 NSEventTrackingRunLoopMode。当然你也可以通过调用 CFRunLoopAddCommonMode() 方法将自定义 Mode 放到 kCFRunLoopCommonModes 组合）。

五种 Mode 的介绍如下：

mode	name	description
Default	NSDefaultRunLoopMode (Cocoa) kCFRunLoopDefaultMode (Core Foundation)	用的最多的模式，大多数情况下应该使用该模式开始 RunLoop 并配置 input source
Connection	NSConnectionReplyMode (Cocoa)	Cocoa 用这个模式结合 NSConnection 对象监测回应，我们应该很少使用这种模式
Modal	NSModalPanelRunLoopMode (Cocoa)	Cocoa 用此模式来表示用于模态面板的事件
Event tracking	NSEventTrackingRunLoopMode (Cocoa)	Cocoa 使用此模式在鼠标拖动 loop 和其它用户界面跟踪 loop 期间限制传入事件
Common modes	NSRunLoopCommonModes (Cocoa) kCFRunLoopCommonModes (Core Foundation)	这是一种可配置的常用模式。将输入源与这些模式相关联会与组中的每个模式相关联。Cocoa applications 里面包括 Default、Modal 和 Event tracking。Core Foundation 只包含默认模式，你可以自己把自定义 mode 用 CFRunLoopAddCommonMode 函数加入到集合中。

RunLoop Source

RunLoop source 分为 Source、Observer、Timer 三种，它们统称为 ModelItem。

CFRunLoopSource

根据官方的描述，CFRunLoopSource 是对 input sources 的抽象。CFRunLoopSource 分为 source0 和 source1 两个版本，它的结构如下：

struct __CFRunLoopSource {
  CFRuntimeBase _base;
  uint32_t _bits; // 用于标记 Signaled 状态，source0 只有在被标记为 Signaled 状态，才会被处理
  pthread_mutex_t _lock;
  CFIndex _order; /* immutable */
  CFMutableBagRef _runLoops;
  union {
    CFRunLoopSourceContext version0; /* immutable, except invalidation */
    CFRunLoopSourceContext1 version1; /* immutable, except invalidation */
  } _context;
};

source0 是 App 内部事件，由 App 自己管理的 UIEvent、CFSocket 都是 source0.当一个 source0 事件准备执行的时候，必须要先把它标记为 signal 状态，以下是 source0 的结构体：

typedef struct {
  CFIndex version;
  void *info;
  const void *(*retain)(const void *info);
  void (*release)(const void *info);
  CFStringRef (*copyDescription)(const void *info);
  Boolean (*equal)(const void *info1, const void *info2);
  CFHashCode (*hash)(const void *info);
  void (*schedule)(void *info, CFRunLoopRef rl, CFStringRef mode);
  void (*cancel)(void *info, CFRunLoopRef rl, CFStringRef mode);
  void (*perform)(void *info);
} CFRunLoopSourceContext;

source0 是非基于 Port 的。只包含了一个回调（函数指针），它并不能主动触发事件。石永师，你需要先调用 CFRunLoopSourceSignal(source)，将这个 Source 标记为待处理，然后手动调用 CFRunLoopWakeUp(runloop) 来唤醒 RunLoop，让其处理这个事件。

source1 由 RunLoop 和内核管理，source1 带有 mach_port_t，可以接收内核消息并触发回调，以下是 source1 的结构体：

typedef struct {
  CFIndex version
  void *info;
  const void *(*retain)(const void *info);
  void (*release)(const void *info);
  CFStringRef (*copyDescription)(const void *info);
  Boolean (*equal)(const void *info1, const void *info2);
  CFHashCode (*hash)(const void *info);
#if ((TARGET_OS_MAC && !(TARGET_OS_EMBEDDED || TARGET_OS_IPHONE)) || (TARGET_OS_EMBEDDED || TARGET_OS_IPHONE))
  mach_port_t (*getPort)(void *info);
  void * (*perform)(void *msg, CFIndex size, CFAllocatorRef allocator, void *info);
#else
  void * (*getPort)(void *info);
  void (*perform)(void *info);
#endif
} CFRunLoopSourceContext1;

Source1 除了包含回调指针外包含一个 mach port，Source1 可以监听系统端口和通过内核和其他线程通信，接收、分发系统事件，它能够主动唤醒 RunLoop（由操作系统内核进行管理，例如 CFMessagePort 消息）。官方也指出可以自定义 Source，因此对于 CFRunLoopSourceRef 来说它更像一种协议，框架已经默认定义了两种实现，如果有必要开发人员也可以自定义，详细情况可以查看官方文档。

CFRunLoopObserver

CFRunLoopObserver 是观察者，可以观察 RunLoop 的各种状态，并抛出回调

struct __CFRunLoopObserver {
  CFRuntimeBase _base;
  pthread_mutex_t _lock;
  CFRunLoopARef _runLoop;
  CFIndex _rlCount;
  CFOptionFlags _activities; /* immutable */
  CFIndex _order; /* immutable */
  CFRunLoopObserverCallBack _callout; /* immutable */
  CFRunLoopObserverContext _context; /* immutable, except invalidation */
};

CFRunLoopObserver 可以观察的状态有如下6种：

/* Run Loop Observer Activities */
typedef CF_OPTIONS(CFOptionFlags, CFRunLoopActivity) {
  kCFRunLoopEntry = (1UL << 0), // 即将进入 run loop
  kCFRunLoopBeforeTimers = (1UL << 1), // 即将处理 timer
  kCFRunLoopBeforeSources = (1UL << 2), // 即将处理 source
  kCFRunLoopBeforeWaiting = (1UL << 5), // 即将进入休眠
  kCFRunLoopAfterWaiting = (1UL << 6), // 被唤醒但是还没开始处理事件
  kCFRunLoopExit = (1UL << 7), // run loop 已经退出
  kCFRunLoopAllActivities = 0x0FFFFFFFU
};

RunLoop 通过监控 Source 来决定有没有任务要做，除此之外，我们还可以用 RunLoop Observer 来监控 RunLoop 本身的状态。RunLoop Observer 可以监控上面的 RunLoop 事件，具体流程如下图。

runLoopFCD2.jpg

CFRunLoopTimer

CFRunLoopTimer 是定时器，可以在设定的时间点抛出回调，它的结构如下：

struct __CFRunLoopTimer {
  CFRuntimeBase _base;
  uint16_t _bits; // 标记fire状态
  pthread_mutex_t _block;
  CFRunLoopRef _runLoop; // 添加该 timer 的 runloop
  CFMutableSetRef _rlModes; // 存放所有包含该 timer 的 modeName，意味着一个 timer 可能会在多个 mode 中存在
  CFAbsoluteTime _nextFireDate;
  CFTimeInterval _interval; // 理想时间间隔 /* immutable */
  CFTimeInterval _tolerance; // 时间偏差 /* mutable */
  uint64_t _fireTSR; /* TRS units */
  CFIndex _order; /* immutable */
  CFRunLoopTimerCallBack _callout; /* immutable */
  CFRunLoopTimerContext _context; /* immutable, except invalidation */
};

另外根据官方文档的描述，CFRunLoopTimer和NSTimer是toll-free bridged的，可以相互转换。

CFRunLoopTimer is “toll-free bridged” with its Cocoa Foundation counterpart, NSTimer. This means that the Core Foundation type is interchangeable in function or method calls with the bridged Foundation object.

所有 CFRunLoopTimer 具有以下特征：

CFRunLoopTimer 是定时器，可以在设定的时间点抛出回调
CFRunLoopTimer 和 NSTimer 是 toll-free bridged 的，可以互相转换

RunLoop 实现

下面从以下3个方面介绍RunLoop的实现。

获取 RunLoop
添加 Mode
添加 RunLoop Source

获取 RunLoop

从苹果开放的 API 来看，不允许我们直接创建 RunLoop 对象，只能通过以下几个函数来获取 RunLoop:

CFRunLoopRef CFRunLoopGetCurrent(void)
CFRunLoopRef CFRunLoopGetMain(void)
+(NSRunLoop *)currentRunLoop
+(NSRunLoop *)mainRunLoop

前两者是 Core Foundation 中的 API，后两者是 Foundation 中的 API。

那么RunLoop是什么时候被创建的呢？

我们从下面几个函数内部看看。

CFRunLoopGetCurrent

CFRunLoopRef CFRunLoopGetCurrent(void) {
  CHECK_FOR_FORK();
  CFRunLoopRef rl = (CFRunLoopRef)_CFGetTSD(__CFTSDKeyRunLoop);
  if (rl) return rl;
  // 传入当前线程
  return _CFRunLoopGet0(pthread_self());
}

在 CFRunLoopGetCurrent 函数中调用了 _CFRunLoopGet0()，传入的参数是当前线程 pthread_self()。这里可以看出，CFRunLoopGetCurrent 函数必须要在线程内部调用，获取当前线程的 RunLoop。也就是说子线程的 RunLoop 必须要在子线程内部获取。

CFRunLoopGetMain

// 取主线程的 RunLoop
CFRunLoopRef CFRunLoopGetMain(void) {
  CHECK_FOR_FORK();
  static CFRunLoopRef __main = NULL; no retain needed
  // 传入主线程
 if (!__main) __main = _CFRunLoopGet0(pthread_main_thread_np()); // no CAS needed
  return __main;
}

在 CFRunLoopGetMain 函数内部也调用了 _CFRunLoopGet0()，传入的参数是主线程 pthread_main_thread_np()。可以看出，CFRunLoopGetMain() 不管在主线程还是子线程中调用，都可以获取到主线程的 RunLoop。

CFRunLoopGet0

前面两个函数都使用了 CFRunLoopGet0 实现传入线程的函数，下面看下 CFRunLoopGet0 的结构是咋样的。

static CFMutableDictionaryRef __CFRunLoops = NULL;
static CFSpinLock_t loopsLock = CFSpinLockInit;
// t==0 is a synonym for "main thread" that always works
// 根据线程取 RunLoop
CF_EXPORT CFRunLoopRef _CFRunLoopGet0(pthread_t t) {
  if (pthread_equal(t, kNilPthreadT)) {
    t = pthread_main_thread_np();
  }
  __CFSpinLock(&loopsLock);
  // 如果存储 RunLoop 的字典不存在
  if (!__CFRunLoops) {
    __CFSpinUnlock(&loopsLock);
    // 创建一个临时字典 dict
    CFMutableDictionaryRef dict = CFDictionaryCreateMutable(kCFAllocatorSystemDefault, 0, NULL, &kCFTypeDictionaryValueCallBacks);
    // 创建主线程的 RunLoop
    CFRunLoopRef mainLoop = _CFRunLoopCreate(pthread_main_thread_np());
    // 把主线程的 RunLoop 保存到 dict 中，key 是线程，value 是 RunLoop
    CFDictionarySetValue(dict, pthreadPointer(pthread_main_thread_np()), mainLoop);
    // 此处 NULL 和 __CFRunLoops 指针都指向 NULL，匹配，所有将 dict 写到 __CFRunLoops
    if (!OSAtomicCompareAndSwapPtrBarrier(NULL, dict, (void *volatile *)&_CFRunLoops)) {
      // 释放 dict
      CFRelease(dict);
    }
    // 释放 mainrunloop
    CFRelease(mainLoop);
    __CFSpinLock(&loopsLock);
  }
  //以上说明，第一次进来的时候，不管是getMainRunloop还是get子线程的runloop，主线程的runloop总是会被创建
  //从字典__CFRunLoops中获取传入线程t的runloop
  CFRunLoopRef loop = (CFRunLoopRef)CFDictionaryGetValue(__CFRunLoops, pthreadPointer(t));
  __CFSpinUnlock(&loopsLock);
  // 如果没有获取到
  if (!loop) {
    // 根据线程 t 创建一个 runloop
    CFRunLoopRef newLoop = __CFRunLoopCreat(t);
    __CFSpinLock(&loopsLock);
    loop = (CFRunLoopRef)CFDictionaryGetValue(__CFRunLoops, pthreadPointer(t));
    if (!loop) {
      // 把 newLoop 存入字典 __CFRunLoops，key 是线程 t
      CFDictionarySetValue(__CFRunLoops, pthreadPoint(t), newLoop);
      loop = newLoop;
    }
    // don't release run loops inside the loopsLock, because CFRunLoopDellocate may end up taking it
    __CFSpinUnlock(&loopsLock);
    CFRelease(newLoop);
  }
  // 如果传入线程就是当前线程
  if (pthread_equal(t, pthread_self())) {
    _CFSetTSD(__CFTSDKeyRunLoop, (void *)loop, NULL);
    if (0 == _CFGetTSD(__CFTSDKeyRunLoopCntr)) {
      // 注册一个回调，当线程销毁时，销毁对应的 RunLoop
      _CFSetTSD(__CFTSDkeyRunLoopCntr, (void *)(PTHREAD_DESTRUCTOR_ITERATIONS-1), (void (*)(void *))__CFFinalizeRunLoop);
    }
  }
  return loop;
}

这段代码可以总结得出以下结论：

RunLoop 和线程是一一对应的，对应的方式是以 key-value 的方式保存在一个全局字典中
主线程的 RunLoop 会在初始化全局字典时创建
子线程的 RunLoop 会在第一次获取的时候创建，如果不获取的话就一直不会被创建
RunLoop 会在线程销毁时销毁

添加 Mode

在 Core Foundation 中，针对 Mode 的操作，苹果只开放了以下三个 API（Cocoa 中也有功能一样的函数，不再列出）：

CFRunLoopAddCommonMode(CFRunLoopRef rl, CFStringRef mode)
CFStringRef CFRunLoopCopyCurrentMode(CFRunLoopRef rl)
CFArrayRef CFRunLoopCopyAllModes(CFRunLoopRef rl)

CFRunLoopAddCommonMode Adds a mode to the set of run loop common modes. 向当前RunLoop的common modes中添加一个mode。

CFRunLoopCopyCurrentMode Returns the name of the mode in which a given run loop is currently running. 返回当前运行的mode的name

CFRunLoopCopyAllModes Returns an array that contains all the defined modes for a CFRunLoop object. 返回当前RunLoop的所有mode

我们没有办法直接创建一个 CFRunLoopMode 对象，但是我们可以调用 CFRunLoopAddCommonMode 传入一个字符串向 RunLoop 中添加 Mode，传入的字符串即为 Mode 的名字，Mode 对象应该是此时在 RunLoop 内部创建的。下面来看一下源码。

CFRunLoopAddCommonMode

void CFRunLoopAddCommonMode(CFRunLoopRef rl, CFStringRef modeName) {
  CHECK_FOR_FORK();
  if (__CFRunLoopIsDeallocating(rl)) return;
  __CFRunLoopLock(rl);
  // 看 rl 中是否已经有这个 mode，如果有就什么也不做
  if (!CFSetContainsValue(rl->_commonModes, modeName)) {
    CFSetRef set = rl->_commonModeItems ? CFSetCreateCopy(kCFAllocatorSystemDefault, rl->_commonModeItems) : NULL;
    // 把 modeName 添加到 RunLoop 的 _commonModes 中
    CFSetAddValue(rl->_commonModes, modeName);
    if (NULL != set) {
      CFTypeRef context[2] = {rl, modeName};
      /* add all common-modes items to new mode */
      // 这里调用 CFRunLoopAddSource/CFRunLoopAddObserver/CFRunLoopAddTimer 的时候会调用
      // __CFRunLoopFindMode(rl, modeName, true), CFRunLoopMode 对象在这个时候被创建
      CFSetApplyFunction(set, (__CFRunLoopAddItemsToCommonMode), (void *)context);
      CFRelease(set);
    }
  } else {
  }
  __CFRunLoopUnlock(rl);
}

可以看得出：

modeName 不能重复，modeName 是 mode 的唯一标识符
RunLoop 的 _commonModes 数组存放所有被标记为 common 的 mode 的名称
添加 commonMode 会把commonModelItems 数组中的所有 source 同步到新添加的 mode 中
CFRunLoopMode 对象在 CFRunLoopAddItemsToCommonMode 函数中调用 CFRunLoopFindMode 时被创建

CFRunLoopCopyCurrentMode/CFRunLoopCopyAllModes

CFRunLoopCopyCurrentMode 和 CFRunLoopCopyAllModes 的内部逻辑比较简单，直接取 RunLoop 的 _currentMode 和 _modes 返回，就不贴源码了。

添加 RunLoop Source (ModeItem)

我们可以通过以下接口添加/移除各种事件:

void CFRunLoopAddSource(CFRunLoopRef rl, CFRunLoopSourceRef source, CFStringRef mode)
void CFRunLoopRemoveSource(CFRunLoopRef rl, CFRunLoopSourceRef source, CFStringRef mode)
void CFRunLoopAddObserver(CFRunLoopRef rl, CFRunLoopObserverRef observer, CFStringRef mode)
void CFRunLoopRemoveObserver(CFRunLoopRef rl, CFRunLoopObserverRef observer, CFStringRef mode)
void CFRunLoopAddTimer(CFRunLoopRef rl, CFRunLoopTimerRef timer, CFStringRef mode)
void CFRunLoopRemoveTimer(CFRunLoopRef rl, CFRunLoopTimerRef timer, CFStringRef mode)

CFRunLoopAddSource

CFRunLoopAddSource 的代码结构如下：

//添加source事件
void CFRunLoopAddSource(CFRunLoopRef rl, CFRunLoopSourceRef rls, CFStringRef modeName) {    /* DOES CALLOUT */
  CHECK_FOR_FORK();
  if (__CFRunLoopIsDeallocating(rl)) return;
  if (!__CFIsValid(rls)) return;
  Boolean doVer0Callout = false;
  __CFRunLoopLock(rl);
  // 如果是 kCFRunLoopCommonModes
  if (modeName == kCFRunLoopCommonModes) {
    // 如果 runloop 的 _commonModes 存在，则 copy 一个新的复制给 set
    CFSetRef set = rl->commonModes ? CFSetCreateCopy(kCFAllocatorSystemDefault, rl->_commonModes) : NULL;
    // 如果 runloop 的 _commonModeItems 为空
    if (NULL == rl->_commonModeItems) {
      // 先初始化
      rl->_commonModeItems = CFSetCreateMutable(kCFAllocatorSystemDefault, 0, &kCFTypeSetCallBacks);
    }
    // 把传入的 CFRunLoopSourceRef 加入 _commonModeItems
    CFSetAddValue(rl->_commonModeItems, rls);
    // 如果刚才 set copy 到的数组里面有数据
    if (NULL != set) {
      CFTypeRef context[2] = {rl, rls};
      /* add new item to all common-modes */
      // 则把set里的所有 mode 都执行一遍 __CFRunLoopAddItemToCommonModes 函数
      CFSetApplyFunction(set, (__CFRunLoopAddItemToCommonModes), (void *)context);
      CFRelease(set);
    }
    // 以上分支的逻辑就是，如果你往 kCFRunLoopCommonModes 里面添加一个 source，那么所有 _commonModes 里面的 mode 都会添加这个 source
  } else {
    // 根据 modeName 查找 mode
    CFRunLoopModeRef rlm = __CFRunLoopFIndMode(rl, modeName, true);
    // 如果 _sources0 不存在，则初始化 _sources0 和 _portToV1SourceMap
    if (NULL != rlm && NULL == rlm->_sources0) {
      rlm->sources0 = CFSetCreateMutable(kCFAllocatorSystemDefault, 0, &kCFTypeSetCallBacks);
      rlm->sources1 = CFSetCreateMutable(kCFAllocatorSystemDefault, 0, &kCFTypeSetCallBadks);
      rlm->_portToV1SourceMap = CFDictionaryCreateMutable(kCFAllocatorSystemDefault, 0, NULL, NULL);
    }
    // 如果 _sources0 和 _source1 中都不包含传入的 source
    if (NULL != rlm && !CFSetContainsValue(rlm->_sources0, rls) && !CFSetContainsValue(rlm->_sources1, rls)) {
      // 如果 version 是 0，则加到 _sources0
      if (0 == rls->_context.version0.version) {
        CFSetAddValue(rlm->_sources0, rls);
      // 如果 version 是 1，则加到 _sources1
      } else if (1 == rls->_context.version0.version) {
        CFSetAddValue(rlm->_sources1, rls);
        __CFPort src_port = rls->_context.version1.getPort(rls->_context.version1.info);
        if (CFPORT_NULL != src_port) {
          // 此处只有在加到 source1 的时候才会把 souce 和 一个 mach_port_t 对应起来
          // 可以理解为，source1 可以通过内核向其端口发送消息来主动唤醒 runloop
          CFDictionarySetValue(rlm->_portAToV1SourceMap, (const void *)(uintptr_t)src_port, rls);
          __CFPortSetInsert(scr_port, rlm->_portSet);
        }
      }
      __CFRunLoopSourceLock(rls);
      // 把 runloop 加入到 source 的 _runLoops 中
      if (NULL == rls->_runLoops) {
        rls->_runLoops = CFBagCreateMutable(kCFAllocatorSystemDefault, 0, &kCFTypeBagCallBacks);
      }
      CFBagAddValue(rls->_runLoops, rl);
      __CFRunLoopSourceUnlock(rls);
      if (0 == rls->_context.version0.version) {
        if (NULL != rls->_context.version0.schedule) {
          doVer0Callout = true;
        }
      }
    }
    if (NULL != rlm) {
      __CFRunLoopModeUnlock(rlm);
    }
  }
  __CFRunLoopUnlock(rl);
  if (doVer0Callout) {
    // although it looses some protection for the source, we have no choice but
    // to do this after unlocking the run loop and mode locks, to avoid deadlocks
    // where the source wants to take a lock which is already held in another
    // thread which is itself waiting for a run loop/mode lock
    rls->_context.version0.schedule(rls->_context.version0.info, rl, modeName); /* CALLOUT */
  }
}

通过添加 source 的这段代码可以得出如下结论：

如果 modeName 传入 kCFRunLoopCommonModes，则该 source 会被保存到 RunLoop 的 _commonModeItems 中
如果 modeName 传入 kCFRunLoopCommonModes，则该 source 会被添加到所有 commonMode 中
如果 modeName 传入的不是 kCFRunLoopCommonModes，则会先查找该 Mode，如果没有，会创建一个
同一个 source 在一个 mode 中只能被添加一次

CFRunLoopRemoveSource

remove 操作和 add 操作的逻辑基本一致，很容易理解。

//移除source
void CFRunLoopRemoveSource(CFRunLoopRef rl, CFRunLoopSourceRef rls, CFStringRef modeName) { /* DOES CALLOUT */
    CHECK_FOR_FORK();
    Boolean doVer0Callout = false, doRLSRelease = false;
    __CFRunLoopLock(rl);
    //如果是kCFRunLoopCommonModes，则从_commonModes的所有mode中移除该source
    if (modeName == kCFRunLoopCommonModes) {
        if (NULL != rl->_commonModeItems && CFSetContainsValue(rl->_commonModeItems, rls)) {
            CFSetRef set = rl->_commonModes ? CFSetCreateCopy(kCFAllocatorSystemDefault, rl->_commonModes) : NULL;
            CFSetRemoveValue(rl->_commonModeItems, rls);
            if (NULL != set) {
                CFTypeRef context[2] = {rl, rls};
                /* remove new item from all common-modes */
                CFSetApplyFunction(set, (__CFRunLoopRemoveItemFromCommonModes), (void *)context);
                CFRelease(set);
            }
        } else {
        }
    } else {
        //根据modeName查找mode，如果不存在，返回NULL
        CFRunLoopModeRef rlm = __CFRunLoopFindMode(rl, modeName, false);
        if (NULL != rlm && ((NULL != rlm->_sources0 && CFSetContainsValue(rlm->_sources0, rls)) || (NULL != rlm->_sources1 && CFSetContainsValue(rlm->_sources1, rls)))) {
            CFRetain(rls);
            //根据source版本做对应的remove操作
            if (1 == rls->_context.version0.version) {
                __CFPort src_port = rls->_context.version1.getPort(rls->_context.version1.info);
                if (CFPORT_NULL != src_port) {
                    CFDictionaryRemoveValue(rlm->_portToV1SourceMap, (const void *)(uintptr_t)src_port);
                    __CFPortSetRemove(src_port, rlm->_portSet);
                }
            }
            CFSetRemoveValue(rlm->_sources0, rls);
            CFSetRemoveValue(rlm->_sources1, rls);
            __CFRunLoopSourceLock(rls);
            if (NULL != rls->_runLoops) {
                CFBagRemoveValue(rls->_runLoops, rl);
            }
            __CFRunLoopSourceUnlock(rls);
            if (0 == rls->_context.version0.version) {
                if (NULL != rls->_context.version0.cancel) {
                    doVer0Callout = true;
                }
            }
            doRLSRelease = true;
        }
        if (NULL != rlm) {
            __CFRunLoopModeUnlock(rlm);
        }
    }
    __CFRunLoopUnlock(rl);
    if (doVer0Callout) {
        // although it looses some protection for the source, we have no choice but
        // to do this after unlocking the run loop and mode locks, to avoid deadlocks
        // where the source wants to take a lock which is already held in another
        // thread which is itself waiting for a run loop/mode lock
        rls->_context.version0.cancel(rls->_context.version0.info, rl, modeName);   /* CALLOUT */
    }
    if (doRLSRelease) CFRelease(rls);
}

添加 Observer 和 Timer

添加 observer 和 timer 的内部逻辑和添加 source 大体类似。

区别在于 observer 和 timer 只能被添加到一个 RunLoop 的一个或者多个 mode 中，比如一个 timer 被添加到主线程的 RunLoop 中，则不能再把该 timer 添加到子线程的 RunLoop，而 source 没有这个限制，不管是哪个 RunLoop，只要 mode 中没有，就可以添加。

这个区别在文章最开始的结构体中也可以发现，CFRunLoopSource 结构体中有保存 RunLoop 对象的数组，而 CFRunLoopObserver 和 CFRunLoopTimer 只有单个 RunLoop 对象。

RunLoop 运行

在 Core Foundation 中我们可以通过以下 2 个 API 来让 RunLoop 运行：

void CFRunLoopRun(void)
在默认的 mode 下运行当前线程的 RunLoop
CFRunLoopRunResult CFRunLoopRunInMode(CFStringRef mode, CFTimeInterval seconds, Boolean returnAfterSourceHandled)
在指定 mode 下运行当前线程的 RunLoop

CFRunLoopRun

// 默认运行 runloop 的 kCFRunLoopDefaultMode
void CFRunLoopRun(void) { /* DOES CALLOUT */
  int32_t result;
  do {
    // 默认在 KCFRunLoopDefaultMode 下运行 runloop
    result = CFRunLoopRunSpecific(CFRunLoopGetCurrent(), kCFRunLoopDefaultMode, 1.0e10, false);
    CHECK_FOR_FORK();
  } while (kCFRunLoopRunStopped != result && kCFRunLoopRunFinished != result);
}

在 CFRunLoopRun 函数中调用了 CFRunLoopRunSpecific 函数，runloop 参数传入当前 RunLoop 对象，modeName 参数传入 KCFRunLoopDefaultMode。验证了前面文档的解释。

CFRunLoopRunInMode

SInt32 CFRunLoopRunInMode(CFStringRef modeName, CFTimeInterval seconds, Boolean returnAfterSourceHandled) {
  CHECK_FOR_FORK();
  return CFRunLoopRunSpecific(CFRunLoopGetCurrent(), modeName, seconds, returnAfterSourceHandled);
}

在 CFRunLoopRunInMode 函数中也调用了 CFRunLoopRunSpecific 函数，runloop 参数传入当前 RunLoop 对象，modeName 参数继续传递 CFRunLoopRunInMode 传入的 modeName。也验证了前文文档的解释。

这里还可以看出，虽然 RunLoop 有很多个 mode，但是 RunLoop 在 run 的时候必须只能指定其中一个 mode，运行起来后，被指定的 mode 即为 currentMode。

这 2 个函数都看不出来 RunLoop 是怎么 run 起来的。

接下来我们继续探索一下 CFRunLoopRunSpecific 函数里面都干了什么，看看 RunLoop 具体是怎么 run 的。

CFRunLoopRunSpecific

 * 指定 mode 运行 runloop
 * @param rl 当前运行的 runloop
 * @param modeName 需要运行的 mode 的 name
 * @param seconds  runloop 的超时时间
 * @param returnAfterSourceHandled 是否处理完事件就返回
 */
SInt32 CFRunLoopRunSpecific(CFRunLoopRef rl, CFStringRef modeName, CFTimeInterval seconds, Boolean returnAfterSourceHandled) {     /* DOES CALLOUT */
  CHECK_FOR_FORK();
  if (__CFRunLoopIsDeallocating(rl)) return kCFRunLoopRunFinished;
  __CFRunLoopLock(rl);
  // 根据 modeName 找到本次运行的 mode
  CFRunLoopModeRef currentMode = __CFRunLoopFindMode(rl, modeName, false);
  // 如果没有找到 || mode 中没有注册任何事情，则就此停止，不进入循环
  if (NULL == currentMode || __CFRunLoopModeIsEmpty(rl, currentMode, rl->_currentMode)) {
    Boolean did = false;
    if (currentMode) __CFRunLoopModeUnlock(currentMode);
    __CFRunLoopUnlock(rl);
    return did ? kCFRunLoopRunHandledSource: kCFRunLoopRunFinished;
  }
  volatile _per_run_data *previousPerRun = __CFRunLoopPushPerRunData(rl);
  // 取上一次运行的 mode
  CFRunLoopModeRef previousMode = rl->_currentMode;
  // 如果本次 mode 和上一次的 mode 一致
  rl->_currentMode = currentMode;
  // 初始化一个 result 为 kCFRunLoopRunFinished
  int32_t result = kCFRunLoopRunFinished;

  // 1.通知 observer 即将进入 runloop
  if (currentMode->_observerMask & kCFRunLoopEntry) __CFRunLoopDoObservers(rl, currentMode, kCFRunLoopEntry);
  result = __CFRunLoopRun(rl, currentMode, seconds, returnAfterSourceHandled, previousMode);
  // 10.通知 observer 已经退出 runloop
  if (currentMode->_observerMask & kCFRunLoopExit) __CFRunLoopDoObservers(rl, currentMode, kCFRunLoopExit);
  
  __CFRunLoopModeUnlock(currentMode);
  __CFRunLoopPopPerRunData(rl, previousPerRun);
  rl->_currentMode = previousMode;
  __CFRunLoopUnlock(rl);
  return result;
}

通过 CFRunLoopRunSpecific 的内部逻辑，我们可以得出：

如果指定一个不存在的 mode 来运行 RunLoop，那么会失败，mode 不会被创建，所有这里传入的 mode 必须是存在的
如果指定了一个 mode，但是这个 mode 中不包含人 modeItem，那么 RunLoop 也不会运行，所以必须要传入至少包含一个 modeItem 的 mode
在进入 run loop 之前通知 observer，状态为 kCFRunLoopEntry
在退出 run loop 之后通知 observer，状态为 kCFRunLoopExit

RunLoop 的运行的最核心函数是 __CFRunLoopRun，接下来我们分析 __CFRunLoopRun 的源码。

__CFRunLoopRun

这段代码比较长,请做好心理准备，我已经加了比较详细的注释。本节开头的 run loop 运行步骤 2~9 步都在下面的代码中得到验证。

/**
 *  运行run loop
 *
 *  @param rl              运行的RunLoop对象
 *  @param rlm             运行的mode
 *  @param seconds         run loop超时时间
 *  @param stopAfterHandle true:run loop处理完事件就退出  false:一直运行直到超时或者被手动终止
 *  @param previousMode    上一次运行的mode
 *
 *  @return 返回4种状态
 */
static int32_t __CFRunLoopRun(CFRunLoopRef rl, CFRunLoopModeRef rlm, CFTimeInterval seconds, Boolean stopAfterHandle, CFRunLoopModeRef previousMode) {
  // 获取系统启动后的 CPU 运行时间，用于控制超时时间
  uint64_t startTSR = mach_absolute_time();
  // 如果 RunLoop 或者 mode 是 stop 状态，则直接 return，不进入循环
  if (__CFRunLoopIsStopped(rl)) {
    __CFRunLoopUnsetStopped(rl);
    return kCFRunLoopRunStopped;
  } else if (rlm -> _stopped) {
    rlm->_stopped = false;
    return kCFRunLoopRunStopped;
  }
  // mach 端口，在内核中，消息在端口之间传递，初始为0
  mach_port_name_t dispatchPort = MACH_PORT_NULL;
  // 判断是否为主线程
  Boolen libdispatchQSafe = pthread_main_np() && ((HANDLE_DISPATCH_ON_BASE_INVOCATION_ONLY && NULL == previousMode) || (!HANDLE_DISPATCH_ON_BASE_INVOCATION_ONLY && 0 == _CFGetTSD(__CFTSDKeyIsInGCDMainQ)));
  // 如果在主线程 && runloop 是主线程的 runloop && 该 mode 是 commonMode，则给 mach 端口赋值为主线程收发消息的端口
  if (libdispatchQSafe && (CFRunLoopGetMain() == rl) && CFSetContainsValue(rl->_commonModes, rlm->_name)) 
    dispatchPort = _dispatch_get_main_queue_port_4CF();

#if USE_DISPATCH_SOURCE_FOR_TIMERS
  mach_port_name_t modeQueuePort = MACH_PORT_NULL;
  if (rlm->_queue) {
    // mode 赋值为 dispatch 端口 _dispatch_runloop_root_queue_perform_4CF
    modeQueuePort = _dispatch_runloop_root_queue_get_port_4FC(rlm->_queue);
    if (!modeQueuePort) {
      CRASH("Unable to get port for run loop mode queue (%d)", -1)
    }
  }
#endif
  // GCD 管理的定时器，用于实现 runloop 的超时机制
  dispatch_source_t timeout_timer = NULL;
  struct __timeout_context *timeout_context = (struct __timeout_context *)malloc(sizeof(*timeout_context));
  // 立即超时
  if (seconds <= 0.0) { // instant timeout
    seconds = 0.0;
    timeout_context->termTSR = 0ULL;
  }
  // seconds 为超时时间，超时执行 __CFRunLoopTimeout 函数
  else if (seconds <= TIMER_INTERVAL_LIMIT) {
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_UEUE_PRIOITY_HIGH, DISPATCH_QUEUE_OVERCOMMIT);
    timeout_timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
    dispatch_retain(timeout_timer);
    timeout_context->ds = timeout_timer;
    timeout_context->rl = (CFRunLoopRef)CFRetain(rl);
    timeout_context->termTSR = startTSR + __CFTimeIntervalToTSR(seconds);
    dispatch_set_context(timeout_timer, timeout_context); // source gets ownership of context
    dispatch_source_set_event_handler_f(timout_timer, __CFRunLoopTimeout);
    dispatch_source_set_cancel_handler_f(timeout_timer, __CFRunLoopTimeoutCancel);
    uint64_t ns_at = (uint64_t)((__CFTSRToTimeInterval(startTSR) + seconds) * 1000000000ULL);
    dispatch_source_set_timer(timeout_timer, dispatch_time(1, ns_at), DISPATCH_IME_FOREVER, 1000ULL);
    dispatch_resume(timeout_timer);
  }
  // 永不超时
  else {
    seconds = 9999999999.0;
    timeout_context->termTSR = UNT64_MAX;
  }
  // 标志位默认为 true
  Boolean didDispatchPortLastTime = true;
  // 记录最后 runloop 状态，用于 return
  int32_t reVal = 0;
  do {
    // 初始化一个存放内核消息的缓冲地
    uint8_t msg_buffer[3 * 1024];
#if DEPLOYMENAT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
    match_msg_header_t *msg = NULL;
    mach_port_t livePort = MACH_PORT_NULL;
#elif DEPLOYMENT_TARGET_WINDOWS
    HANDLE livePort = NULL;
    Boolean windowsMessageReceived = false;
#endif
    // 取所需要监听的 port
    __CFPortSet waitSet = rlm->_portSet;
    // 设置 RunLoop 为可以被唤醒状态
    __CFRunLoopUnsetIgnoreWakeUps(rl);
  
    // 2.通知 observer，即将触发 timer 回调，处理 timer 事件
    if (rlm->_observerMask & kCFRunLoopBeforeTimes) __CFRunLoopDoObservers(rl, rlm, kCFRunLoopBeforeTimers);
    // 3.通知 observer，即将触发 Source0 回调
    if (rlm->_observerMask & kCFRunLoopBeforeSources) __CFRunLoopDoObservers(rl, rlm, kCFRunLoopBeforeSources);
    // 执行加入当前 runloop 的 block
    __CFRunLoopDoBlocks(rl, rlm);

    // 4. 处理 source0 事件
    // 有事件处理返回 true，没有事件返回 false
    Boolean sourceHandleThisLoop = __CFRunLoopDoSources0(rl, rlm, stopAfterHandle);
    if (sourceHandledThisLoop) {
      // 执行加入当前 runloop 的 block
      __CFRunLoopDoBlocks(rl, rlm);
    }
    // 如果没有 Sources0 事件处理并且没有超市，poll 为 false
    Boolean poll = sourceHandledThisLoop || (0ULL == timeout_context->termTSR);
    // 第一次 do...while 循环不会走该分支，因为 didDispatchPortLastTime 初始化是 true
    if (MACH_PORT_NULL !+ dispatchPort && !didDispatchPortLastTime) {
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
      //从缓冲区读取消息
      msg = (mach_msg_header_t *)msg_buffer;
      // 5. 接收 dispatchPort 端口消息，(接收 source1 事件)
      if（__CFRunLoopServiceMachPort(dispatchPort, &msg, sizeof(msg_buffer), &livePort, 0)) {
        // 如果收到消息的话，前往第 9 步开始处理 msg
        goto handle_msg;
      }
#elif DEPLOYMENT_TARGET_WINDOWS
      if (__CFRunLoopWaitForMultipleObjects(NULL, &dispatchPort, 0, 0, &livePort, NULL)) {
        goto handle_msg;
      }
#endif
    }
    didDispatchPortLastTime = false;
    // 6. 通知观察者 RunLoop 即将进入休眠
    if (!poll && (rlm->_observerMask & kCFRunLoopBeforeWaiting)) __CFRunLoopDoObservers(rl, rlm, kCFRunLoopBeforeWaiting);
    // 设置 RunLoop 为休眠zhuangt
    __CFRunLoopSetSleeping(rl);
    // do not do any user callouts after this point (after notifying of sleeping)
    // Must push the local-to-this-activation ports in on every loop
    // iteration, as this mode could be run re-entrantly and we don't
    // want these ports to get serviced.
    __CFPortSetInsert(dispatchPort, waitSet);
    __CFRunLoopModeUnlock(rlm);
    __CFRunLoopUnlock(rl);
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
#if USE_DISPATCH_SOURCE_FOR_TIMERS
    // 这里有个内循环，用于接收等待端口的消息
    // 进入此循环后，线程进入休眠，直到收到新消息才跳出循环，继续执行 run loop
    do {
      if (kCFUseCollectableAllocator) {
        objc_clear_stack(0);
        memset(msg_buffer, 0, sizeof(msg_buffer));
      }
      msg = (mach_msg_header_t *)msg_buffer;
      // 7.接收 waitSet 端口的消息
      __CFRunLoopServiceMachPort(waitSet, &msg, sizeof(msg_buffer), &livePort, poll ? 0: TIMEOUT_INFINTY);
      // 收到消息之后，livePort 的值为 msg->msgh_local_port
      if (modeQueuePort != MACH_PORT_NULL && livePort == modeQueuePort) {
        // Drain the internal queue. If one of the callout blocks sets the timerFired flag, break out and service the timer.
        while (_dispatch_runloop_root_queue_perform_4CF(rlm->_queue));
        if (rlm->_timerFired) {
          rlm->_timerFired = false;
          break;
        } else {
          if (msg && msg != (mach_msg_header_t *)msg_buffer) free(msg);
        }
      } else {
        break;
      }
    } while (1);
#else
    if (kCFUseCollectableAllocator) {
      objc_clear_stack(0);
      memset(msg_buffer, 0, sizeof(msg_buffer));
    }
    msg = (mach_msg_header_t *)msg_buffer;
    __CFRunLoopServiceMachPort(waitSet, &msg, sizeof(msg_buffer), &livePort, poll ? 0: TIMEOUT_INFINITY);
#endif
#elif DEPLOYMENT_TARGET_WINDOWS
    // hear, use the app-suplied message queue mask. They will set this if they are interested in having this run loop receive windows messages.
    __CFRunLoopWaitForMultipleObjects(waitSet, NULL, poll ? 0: TIMEOUT_INFINITY, rlm->_msgQMask, &windowsMessageRecieved);
#endif
    __CFRunLoopLock(rl);
    __CFRunLoopModeLock(rlm);
    // Must remove the local-to-this-activation ports in on every loop
    // iteration, as this mode could be run re-entrantly and we don't
    // want these ports to get serviced. Also, we don't want them left
    // in there if this function returns.
    __CFPortSetRemove(dispatchPort, waitSet);
    __CFRunLoopSetIgnoreWakeUps(rl);
    // 取消 runloop 的休眠状态
    __CFRunLoopUnsetSleeping(rl);
    // 8.通知观察者 runloop 被唤醒
    if (!poll && (rlm->_observerMask & kCFRunLoopAfterWaiting))
      __CFRunLoopDoObserver(rl, rlm, kCFRunLoopAfterWaiting);
    // 9.处理收到的消息
handle_msg:;
    __CFRunLoopSetIgnoreWakeUps(rl);
#if DELOYMENT_TARGET_WINDOWS
    if (windowsMessageReceived) {
      // These Win32 APIs cause a callout, so make sure we're unlocked first and relocked after
      __CFRunLoopModeUnlock(rlm);
      __CFRunLoopUnlock(rl);
      if (rlm->_msgPump) {
        rlm->_msgPump();
      } else {
        MSG msg;
        if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE | PM_NOYIELD)) {
          TranslateMessage(&msg);
          DispatchMessage(&msg);
        }
      }
      __CFRunLoopLock(rl);
      __CFRunLoopModeLock(rlm);
      sourceHandledThisLoop = true;
      // To prevent starvation of sources other than the message queue, we check again to see if any other sources need to be serviced
      // Use 0 for the mask so windows messages are ignored this time. Also use 0 for the timeout, because we're just checking to see if the things are signalled right now -- we will wait on them again later.
      // NOTE: Ignore the dispatch source (it's not in the wait set anymore) and also don't run the observers here since we are polling.
      __CFRunLoopSetSleeping(rl);
      __CFRunLoopModeUnlock(rlm);
      __CFRunLoopUnlock(rl);

      __CFRunLoopWaitForMultipleObjects(waitSet, NULL, 0, 0 &livePort, NULL);

      __CFRunLoopLock(rl);
      __CFRunLoopModeLock(rml);
      __CFRunLoopUnsetSleeping(rl);
    }
#endif
    if (MACH_PORT_NULL == livePort) {
      CFRUNLOOP_WAKEUP_FOR_NOTHING();
      // 通过 CFRunLoopWake 唤醒
    } else if (livePort == rl->_wakeUpPort) {
      // 什么都不干，跳回 2 重新循环
#if DEPLOYMENT_TARGET_WINDOWS
      ResetEvent(rl->_wakeUpPort);
#endif
    }
#if USE_DISPATCH_SOURCE_FOR_TIMERS
    // 如果是定时器事件
    else if (modeQueuePort != MACH_PORT_NULL && livePort == modeQueuePort) {
      CFRUNLOOP_WAKEUP_FOR_TIMER();
      // 9.1 处理 timer 事件
      if (!__CFRunLoopDoTimers(rl, rlm, mach_absolute_time())) {
        __CFArmNextATimerInMode(rlm, rl);
      }
    }
#endif
#if USE_MK_TIMER_TOO
    // 如果是定时器事件
    else if (rlm->_timerPort != MACH_PORT_NULL && livePort == rlm->_timerPort) {
      CFRUNLOOP_WAKEUP_FOR_TIMER();
      // 9.1 处理 timer 事件
      if (!__CFRunLoopDoTimers(rl, rlm, mach_absolute_time())) {
        __CFArmNextTimerInMode(rlm, rl);
      }
    }
#endif
    // 如果是 dispatch 到 main queue 的 block
    else if (livePort == dispatchPort) {
      CFRUNLOOP_WAKEUP_FOR_DISPATCH();
      __CFRunLoopModeUnlock(rlm);
      __CFRunLoopUnlock(rl);
      _CFSetTSD(__CFTSDKeyIsInGCDMainQ, (void *)6, NULL);
#if DEPLOYMENT_TARGET_WINDOWS
      void *msg = 0;
#endif
      // 9.2 执行 block
      __CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__(msg);
      _CFSetTSD(__CFTSDKeyIsInGCDMainQ, (void *)0, NULL);
      __CFRunLoopLock(rl);
      __CFRunLoopModeLock(rlm);
      sourceHandledThisLoop = true;
      didDispatchPortLastTime = true;
    } else {
      CFRUNLOOP_WAKEUP_FOR_SOURCE();
      CFRunLoopSourceRef rls = __CFRunLoopModeFindSourceForMachPort(rl, rlm, livePort);
      // 有 source1 事件待处理
      if (rls) {
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
        mach_msg_header_t *reply = NULL;
        // 9.2 处理 source1 事件
        sourceHandledThisLoop = __CFRunLoopDoSource1(rl, rlm, rls, msg, msg->msgh_size, &reply) || sourceHandledThisLoop;
        if (NULL != reply) {
          (void)mach_msg(reply, MACH_SEND_MSG, reply->msgh_size, 0, MACH_PORT_NULL, 0, MACH_PORT_NULL);
          CFAllocatorDeallocate(kCFAllocatorSystemDefault, reply);
        }  
#elif DEPLOYMENTA_TARGET_WINDOWS
        sourceHandledThisLoop = __CFRunLoopDoSource1(rl, rlm, rls) || sourceHandledThisLoop;
#endif
      }
    }
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
    if (msg && msg != (mach_msg_header_t *)msg_buffer) free(msg);
#endif
    __CFRunLoopDoBlocks(rl, rlm);
    if (sourceHandledThisLoop && stopAfterHandle) {
      // 进入 run loop 时传入的参数，处理完事件就返回
      retVal = kCFRunLoopRunHandledSource;
    } else if (timeout_context->termTSR < mach_absolute_time()) {
      // run loop 超时
      retVal = kCFRunLoopRunTimedOut;
    } else if (__CFRunLoopIsStopped(rl)) {
      // run loop 被手动终止
      __CFRunLoopUnsetStopped(rl);
      retVal = kCFRunLoopRunStopped;
    } else if (rlm->_stopped) {
      // mode 被终止
      rlm->_stopped = false;
      retVal = kCFRunLoopRunStopped;
    } else if (__CFRunLoopModeIsEmpty(rl, rlm, previousMode)) {
      // mode 中没有要处理的事件
      retVal = kCFRunLoopRunFinished;
    }
    // 除了上面这几种情况，都继续循环
  } while (0 == retVal);
  if (timeout_timer) {
    dispatch_source_cancel(timeout_timer);
    dispatch_release(timeout_timer);
  } else {
    free(timeout_context);
  }
  return retVal;
}

__CFRunLoopServiceMachPort

第7步调用了 __CFRunLoopServiceMachPort 函数，这个函数在 run loop 中起到了至关重要的作用，下面给出了详细注释。

/**
 *  接收指定内核端口的消息
 *
 *  @param port        接收消息的端口
 *  @param buffer      消息缓冲区
 *  @param buffer_size 消息缓冲区大小
 *  @param livePort    暂且理解为活动的端口，接收消息成功时候值为msg->msgh_local_port，超时时为MACH_PORT_NULL
 *  @param timeout     超时时间，单位是ms，如果超时，则RunLoop进入休眠状态
 *
 *  @return 接收消息成功时返回true 其他情况返回false
 */
static Boolean __CFRunLoopServiceMachPort(mach_port_name_t port, mach_msg_header_t **buffer, size_t buffer_size, mach_port_t *livePort, mach_msg_timeout_t timeout) {
    Boolean originalBuffer = true;
    kern_return_t ret = KERN_SUCCESS;
    for (;;) {      /* In that sleep of death what nightmares may come ... */
        mach_msg_header_t *msg = (mach_msg_header_t *)*buffer;
        msg->msgh_bits = 0;  //消息头的标志位
        msg->msgh_local_port = port;  //源(发出的消息)或者目标(接收的消息)
        msg->msgh_remote_port = MACH_PORT_NULL; //目标(发出的消息)或者源(接收的消息)
        msg->msgh_size = buffer_size;  //消息缓冲区大小，单位是字节
        msg->msgh_id = 0;  //唯一id
       
        if (TIMEOUT_INFINITY == timeout) { CFRUNLOOP_SLEEP(); } else { CFRUNLOOP_POLL(); }
        
        //通过mach_msg发送或者接收的消息都是指针，
        //如果直接发送或者接收消息体，会频繁进行内存复制，损耗性能
        //所以XNU使用了单一内核的方式来解决该问题，所有内核组件都共享同一个地址空间，因此传递消息时候只需要传递消息的指针
        ret = mach_msg(msg,
                       MACH_RCV_MSG|MACH_RCV_LARGE|((TIMEOUT_INFINITY != timeout) ? MACH_RCV_TIMEOUT : 0)|MACH_RCV_TRAILER_TYPE(MACH_MSG_TRAILER_FORMAT_0)|MACH_RCV_TRAILER_ELEMENTS(MACH_RCV_TRAILER_AV),
                       0,
                       msg->msgh_size,
                       port,
                       timeout,
                       MACH_PORT_NULL);
        CFRUNLOOP_WAKEUP(ret);
        
        //接收/发送消息成功，给livePort赋值为msgh_local_port
        if (MACH_MSG_SUCCESS == ret) {
            *livePort = msg ? msg->msgh_local_port : MACH_PORT_NULL;
            return true;
        }
        
        //MACH_RCV_TIMEOUT
        //超出timeout时间没有收到消息，返回MACH_RCV_TIMED_OUT
        //此时释放缓冲区，把livePort赋值为MACH_PORT_NULL
        if (MACH_RCV_TIMED_OUT == ret) {
            if (!originalBuffer) free(msg);
            *buffer = NULL;
            *livePort = MACH_PORT_NULL;
            return false;
        }
        
        //MACH_RCV_LARGE
        //如果接收缓冲区太小，则将过大的消息放在队列中，并且出错返回MACH_RCV_TOO_LARGE，
        //这种情况下，只返回消息头，调用者可以分配更多的内存
        if (MACH_RCV_TOO_LARGE != ret) break;
        //此处给buffer分配更大内存
        buffer_size = round_msg(msg->msgh_size + MAX_TRAILER_SIZE);
        if (originalBuffer) *buffer = NULL;
        originalBuffer = false;
        *buffer = realloc(*buffer, buffer_size);
    }
    HALT;
    return false;
}

小结

RunLoop 实际很简单，它是一个对象，它和线程是一一对应的，每个线程都有一个对应的 RunLoop 对象，主线程的 RunLoop 会在程序启动时自动创建，子线程需要手动获取来创建。

RunLoop 运行的核心是一个 do..while.. 循环，遍历所有需要处理的事件，如果有事件处理就让线程工作，没有事件处理则让线程休眠，同时等待事件到来。

iOS RunLoop 详解

image.png

RunLoop 概念

RunLoop 介绍

RunLoop 与线程

runLoopFCD.jpg

image.png

RunLoop Mode

image.png

RunLoop Source

CFRunLoopSource

CFRunLoopObserver

runLoopFCD2.jpg

CFRunLoopTimer

RunLoop 实现

获取 RunLoop

CFRunLoopGetCurrent

CFRunLoopGetMain

CFRunLoopGet0

添加 Mode

CFRunLoopAddCommonMode

CFRunLoopCopyCurrentMode/CFRunLoopCopyAllModes

添加 RunLoop Source (ModeItem)

CFRunLoopAddSource

CFRunLoopRemoveSource

添加 Observer 和 Timer

RunLoop 运行

CFRunLoopRun

CFRunLoopRunInMode

CFRunLoopRunSpecific

__CFRunLoopRun

__CFRunLoopServiceMachPort

小结

你可能感兴趣的:(iOS RunLoop 详解)