原文链接重拾RunLoop之源码分析1
虽然自己很早前就看过RunLoop的源码,当时看得时候,有点地方还是比较生涩的。所有抽了个时间,重新整理了一下之前RunLoop的笔记。CoreFoundation源代码关于RunLoop的源码主要集中在CFRunLoop.c
文件中。
RunLoop的获取
苹果并不允许我们直接创建RunLoop,RunLoop的创建在第一次获取的时候,使用[NSRunLoop mainRunLoop]
或CFRunLoopGetMain()
可以获取主线程的RunLoop;通过[NSRunLoop currentRunLoop]
或CFRunLoopGetCurrent()
获取当前线程的RunLoop。
CFRunLoopGetMain()
和CFRunLoopGetCurrent()
的源码如下:
// 主线程的RunLoop
CFRunLoopRef CFRunLoopGetMain(void) {
CHECK_FOR_FORK();//判断是否需要fork 进程
static CFRunLoopRef __main = NULL; // no retain needed
if (!__main) __main = _CFRunLoopGet0(pthread_main_thread_np()); // no CAS needed
return __main;
}
// 当前线程的RunLoop
CFRunLoopRef CFRunLoopGetCurrent(void) {
CHECK_FOR_FORK();
//先从TSD中查找有没有相关的runloop信息,有则返回。
//我们可以理解为runloop不光存在与全局字典中,也存在中TSD中。
CFRunLoopRef rl = (CFRunLoopRef)_CFGetTSD(__CFTSDKeyRunLoop);
if (rl) return rl;
return _CFRunLoopGet0(pthread_self());
}
复制代码
CHECK_FOR_FORK();
用来判断是否需要fork进程,这里我们可以暂时不管。
在获取主线程RunLoop的时候,它使用了static CFRunLoopRef __main
进行保存,当第二次调用CFRunLoopGetMain()
,__main
是有值的,就不会再重新创建,否则就使用_CFRunLoopGet0
进行创建,传入的是pthread_main_thread_np()
即主线程。
在获取当前线程的RunLoop的时候,首页会通过_CFGetTSD
获取RunLoop,如果没有再通过_CFRunLoopGet0
,传入的是当前的线程。
Thread-specific data
Thread-specific data
是线程私有数据就是上面的TSD
,顾名思义就是存一些特定的数据的,RunLoop会保存在线程的私有数据里。
// __CFTSDTable
typedef struct __CFTSDTable {
uint32_t destructorCount;
uintptr_t data[CF_TSD_MAX_SLOTS];
tsdDestructor destructors[CF_TSD_MAX_SLOTS];
} __CFTSDTable;
// _CFGetTSD
CF_EXPORT void *_CFGetTSD(uint32_t slot) {
__CFTSDTable *table = __CFTSDGetTable();
if (!table) { return NULL; }
uintptr_t *slots = (uintptr_t *)(table->data);
return (void *)slots[slot];
}
// _CFSetTSD
CF_EXPORT void *_CFSetTSD(uint32_t slot, void *newVal, tsdDestructor destructor) {
__CFTSDTable *table = __CFTSDGetTable();
if (!table) { return NULL; }
void *oldVal = (void *)table->data[slot];
table->data[slot] = (uintptr_t)newVal;
table->destructors[slot] = destructor;
return oldVal;
}
复制代码
__CFTSDTable
的data
数组用来保存私有数据,destructors
数组用来保存释放函数(后面也会提到)。destructorCount
记录destructors
数组元素的个数。
_CFGetTSD
的作用就是获取__CFTSDTable
的data
数据,并返回slot
的值。
_CFSetTSD
的作用就是给__CFTSDTable
里设置data[slot]
和destructors[slot]
位置的值。
_CFRunLoopGet0
// t==0 is a synonym for "main thread" that always works
// t==0是主线程的代名词
CF_EXPORT CFRunLoopRef _CFRunLoopGet0(pthread_t t) {
// 当前线程为0,则取主线程
if (pthread_equal(t, kNilPthreadT)) {
t = pthread_main_thread_np();
}
__CFLock(&loopsLock);
// __CFRunLoops是一个全局的静态字典。
// 如果该字典为空,就进行以下两步操作
// 1.创建一个临时字典;
// 2.创建主线程的RunLoop,并将它存到临时字典里
// 3.OSAtomicCompareAndSwapPtrBarrier用来将这个临时字典复制到全局字典里;
// 并且使用了锁机制确保安全。
if (!__CFRunLoops) {
__CFUnlock(&loopsLock);
CFMutableDictionaryRef dict = CFDictionaryCreateMutable(kCFAllocatorSystemDefault, 0, NULL, &kCFTypeDictionaryValueCallBacks);
CFRunLoopRef mainLoop = __CFRunLoopCreate(pthread_main_thread_np());
CFDictionarySetValue(dict, pthreadPointer(pthread_main_thread_np()), mainLoop);
if (!OSAtomicCompareAndSwapPtrBarrier(NULL, dict, (void * volatile *)&__CFRunLoops)) {
CFRelease(dict);
}
CFRelease(mainLoop);
__CFLock(&loopsLock);
}
// 当前线程RunLoop的获取,获取不到就使用__CFRunLoopCreate创建一个RunLoop,并保存在全局字典里
CFRunLoopRef loop = (CFRunLoopRef)CFDictionaryGetValue(__CFRunLoops, pthreadPointer(t));
__CFUnlock(&loopsLock);
if (!loop) {
CFRunLoopRef newLoop = __CFRunLoopCreate(t);
__CFLock(&loopsLock);
loop = (CFRunLoopRef)CFDictionaryGetValue(__CFRunLoops, pthreadPointer(t));
if (!loop) {
CFDictionarySetValue(__CFRunLoops, pthreadPointer(t), newLoop);
loop = newLoop;
}
// don't release run loops inside the loopsLock, because CFRunLoopDeallocate may end up taking it
__CFUnlock(&loopsLock);
CFRelease(newLoop);
}
//t为当前线程的话,将loop保存在线程私有数据中
if (pthread_equal(t, pthread_self())) {
//
_CFSetTSD(__CFTSDKeyRunLoop, (void *)loop, NULL);
// __CFFinalizeRunLoop是RunLoop的析构函数,
// PTHREAD_DESTRUCTOR_ITERATIONS 表示是线程退出时销毁线程私有数据的最大次数
// 这也是RunLoop的释放时机--线程退出的时候
if (0 == _CFGetTSD(__CFTSDKeyRunLoopCntr)) {
_CFSetTSD(__CFTSDKeyRunLoopCntr, (void *)(PTHREAD_DESTRUCTOR_ITERATIONS-1), (void (*)(void *))__CFFinalizeRunLoop);
}
}
return loop;
}
复制代码
通过源代码我们可以知道:
- RunLoop和线程之间是一一对应的,它们之间的关系保存在一个全局字典以及线程私有数据中。
- 在线程创建的时候,是没有对应的RunLoop,它的创建是在第一次获取的时候,它的销毁则发生在线程销毁的时候。
之前在看源码的时候有两个地方不是很理解。第一个就是为什么上面的loop要再取一次,在《程序员的自我修养》第29页中得到启发。里面关于单例有这样一段代码:
volatile T* pInst = 0;
T* GetInstance()
{
if(pInst == NULL)
{
lock();
if(pInst == NULL)
pInst = new T;
unlock();
}
return pInst;
}
复制代码
书上只说明双重if在这里可以让lock的调用开销降到最低。为什么有这个效果,这里做一下说明。
在不考虑CPU乱序的情况下,假设有两个线程A、B同时访问GetInstance()
,A和B同时执行第一个判断语句,结果一样,都进入了代码块。lock()
的设定就是只允许一个线程进入,假设A先进入,B在等待。A进入后首先判断pInst
为NULL
,那么new一个对象,然后解锁返回对象。唤醒B,这是B进入发现第二个判断通过不了(因为pInst
已经有值了),这样的话B就直接解锁返回对象。假设只有最外层的判断的话,那么B也会创建一个对象。
我想这里应该也是类似的作用吧。
第二个就是RunLoop销毁的时机,这个会在RunLoop的释放说明。
RunLoop的创建
使用__CFRunLoopCreate
返回一个CFRunLoopRef
的实例,这个函数大致分为两步:
- 使用
_CFRuntimeCreateInstance
创建一个CFRunLoopRef
实例,其实现为CFRuntime.c
文件; - 对
CFRunLoopRef
进行初始化配置,包括调用__CFRunLoopFindMode(loop, kCFRunLoopDefaultMode, true);
。
在__CFRunLoopFindMode
里讲到了RunLoop的定时器,用宏进行了判断
#if DEPLOYMENT_TARGET_MACOSX
#define USE_DISPATCH_SOURCE_FOR_TIMERS 1
#define USE_MK_TIMER_TOO 1
#else
#define USE_DISPATCH_SOURCE_FOR_TIMERS 0
#define USE_MK_TIMER_TOO 1
#endif
复制代码
在MACOSX
下,同时还会有使用GCD Timer
来做定时器,而MK_TIMER
是两个平台下都有的。
RunLoop的释放
关于RunLoop的释放是发生在线程销毁的时候。为什么这么说呢? __CFTSDGetTable()
中有一个__CFTSDFinalize
的析构函数,其实现如下:
static void __CFTSDFinalize(void *arg) {
__CFTSDSetSpecific(arg);
if (!arg || arg == CF_TSD_BAD_PTR) {
return;
}
__CFTSDTable *table = (__CFTSDTable *)arg;
table->destructorCount++;
for (int32_t i = 0; i < CF_TSD_MAX_SLOTS; i++) {
if (table->data[i] && table->destructors[i]) {
uintptr_t old = table->data[i];
table->data[i] = (uintptr_t)NULL;
table->destructors[i]((void *)(old));
}
}
if (table->destructorCount == PTHREAD_DESTRUCTOR_ITERATIONS - 1) { // On PTHREAD_DESTRUCTOR_ITERATIONS-1 call, destroy our data
free(table);
__CFTSDSetSpecific(CF_TSD_BAD_PTR);
return;
}
}
复制代码
我们可以看到,table
会循环遍历data
和destructors
的数据,并且把old
变量作为destructors
里函数的参数。所以当线程退出的时候,会调用到RunLoop的析构函数__CFFinalizeRunLoop
释放RunLoop。
RunLoop运行
RunLoop通过CFRunLoopRun
和CFRunLoopRunInMode
这两个函数运行。
CFRunLoopRun
void CFRunLoopRun(void) {
int32_t result;
do {
result = CFRunLoopRunSpecific(CFRunLoopGetCurrent(), kCFRunLoopDefaultMode, 1.0e10, false);
CHECK_FOR_FORK();
} while (kCFRunLoopRunStopped != result && kCFRunLoopRunFinished != result);
}
复制代码
函数默认在kCFRunLoopDefaultMode
下运行RunLoop,并且一直运行在一个do-while的循环里。 另外函数不会主动调用CFRunLoopStop
函数(kCFRunLoopRunStopped
)或者将所有事件源移除(kCFRunLoopRunFinished
)。 从这里我们也可以了解,如果RunLoop的_currentMode
值变化,只能退出,然后重新指定一个Mode进入。
CFRunLoopRunInMode
SInt32 CFRunLoopRunInMode(CFStringRef modeName, CFTimeInterval seconds, Boolean returnAfterSourceHandled) { /* DOES CALLOUT */
CHECK_FOR_FORK();
return CFRunLoopRunSpecific(CFRunLoopGetCurrent(), modeName, seconds, returnAfterSourceHandled);
}
复制代码
无论是CFRunLoopRun
还是CFRunLoopRunInMode
都是调用了CFRunLoopRunSpecific
。
CFRunLoopRunSpecific
SInt32 CFRunLoopRunSpecific(CFRunLoopRef rl, CFStringRef modeName, CFTimeInterval seconds, Boolean returnAfterSourceHandled) { /* DOES CALLOUT */
CHECK_FOR_FORK();
if (__CFRunLoopIsDeallocating(rl)) return kCFRunLoopRunFinished;
__CFRunLoopLock(rl);
// 首先根据modeName找到对应Mode,如果没有则创建一个新的Mode
CFRunLoopModeRef currentMode = __CFRunLoopFindMode(rl, modeName, false);
// 如果mode为空或者mode中没有相关的source/timer/observer,则不进入循环
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);
CFRunLoopModeRef previousMode = rl->_currentMode;
rl->_currentMode = currentMode;
int32_t result = kCFRunLoopRunFinished;
// 1.通知observer即将进入RunLoop
if (currentMode->_observerMask & kCFRunLoopEntry ) __CFRunLoopDoObservers(rl, currentMode, kCFRunLoopEntry);
// RunLoop真正执行的方法:第2~9步
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;
}
复制代码
__CFRunLoopRun
__CFRunLoopRun
可以说是RunLoop运行的核心方法。由于代码过长,这里对代码进行了删减,简化后的代码如下:
/* rl, rlm are locked on entrance and exit */
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 kCFRunLoopRunStopped,不进入循环
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;
Boolean 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();
// USE_DISPATCH_SOURCE_FOR_TIMERS为1表示在MACOSX下,iOS不会调用这段代码
#if USE_DISPATCH_SOURCE_FOR_TIMERS
...
#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) {
...
}
// 永不超时
else {
seconds = 9999999999.0;
timeout_context->termTSR = UINT64_MAX;
}
// 标志位默认为true
Boolean didDispatchPortLastTime = true;
// 记录最后RunLoop的状态
int32_t retVal = 0;
do {
...
// 需要监听的端口
__CFPortSet waitSet = rlm->_portSet;
// 设置RunLoop为可以被唤醒状态
__CFRunLoopUnsetIgnoreWakeUps(rl);
// 2.通知observer,即将处理Timer事件
if (rlm->_observerMask & kCFRunLoopBeforeTimers) __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 sourceHandledThisLoop = __CFRunLoopDoSources0(rl, rlm, stopAfterHandle);
if (sourceHandledThisLoop) {
__CFRunLoopDoBlocks(rl, rlm);
}
// 如果没有Sources0事件处理并且没有超时,poll为false
Boolean poll = sourceHandledThisLoop || (0ULL == timeout_context->termTSR);
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事件)直接跳到第9步
if (__CFRunLoopServiceMachPort(dispatchPort, &msg, sizeof(msg_buffer), &livePort, 0, &voucherState, NULL)) {
goto handle_msg;
}
#elif DEPLOYMENT_TARGET_WINDOWS
if (__CFRunLoopWaitForMultipleObjects(NULL, &dispatchPort, 0, 0, &livePort, NULL)) {
goto handle_msg;
}
#endif
}
didDispatchPortLastTime = false;
// 6.通知observer,即将进入休眠
if (!poll && (rlm->_observerMask & kCFRunLoopBeforeWaiting)) __CFRunLoopDoObservers(rl, rlm, kCFRunLoopBeforeWaiting);
// 设置RunLoop为休眠状态
__CFRunLoopSetSleeping(rl);
...
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
#if USE_DISPATCH_SOURCE_FOR_TIMERS
...
#else
if (kCFUseCollectableAllocator) {
// objc_clear_stack(0);
// <rdar://problem/16393959>
memset(msg_buffer, 0, sizeof(msg_buffer));
}
msg = (mach_msg_header_t *)msg_buffer;
// 7.接收waitSet端口的消息,这些消息可能是
// 一个基于 port 的Source 的事件。
// 一个 Timer 到时间了
// RunLoop 自身的超时时间到了
// 被其他什么调用者手动唤醒
__CFRunLoopServiceMachPort(waitSet, &msg, sizeof(msg_buffer), &livePort, poll ? 0 : TIMEOUT_INFINITY, &voucherState, &voucherCopy);
#endif
...
// user callouts now OK again
//取消runloop的休眠状态
__CFRunLoopUnsetSleeping(rl);
// 8.通知observer,线程刚被唤醒
if (!poll && (rlm->_observerMask & kCFRunLoopAfterWaiting)) __CFRunLoopDoObservers(rl, rlm, kCFRunLoopAfterWaiting);
//9.处理收到的消息,之后重新进入第2步
handle_msg:;
...
if (MACH_PORT_NULL == livePort) {
CFRUNLOOP_WAKEUP_FOR_NOTHING();
// handle nothing
} else if (livePort == rl->_wakeUpPort) {
CFRUNLOOP_WAKEUP_FOR_WAKEUP();
// 进入第2步重新循环
// do nothing on Mac OS
#if DEPLOYMENT_TARGET_WINDOWS
// Always reset the wake up port, or risk spinning forever
ResetEvent(rl->_wakeUpPort);
#endif
}
#if USE_DISPATCH_SOURCE_FOR_TIMERS
...
// 这里是GCD相关的定时器,可以忽略
#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())) {
// Re-arm the next timer
__CFArmNextTimerInMode(rlm, rl);
}
}
#endif
...
CFRunLoopSourceRef rls = __CFRunLoopModeFindSourceForMachPort(rl, rlm, livePort);
// 有source1事件
if (rls) {
mach_msg_header_t *reply = NULL;
// 9.2 处理source1事件
sourceHandledThisLoop = __CFRunLoopDoSource1(rl, rlm, rls, msg, msg->msgh_size, &reply) || sourceHandledThisLoop;
}
...
if (sourceHandledThisLoop && stopAfterHandle) {
// 处理完事件就返回
retVal = kCFRunLoopRunHandledSource;
} else if (timeout_context->termTSR < mach_absolute_time()) {
// 超时
retVal = kCFRunLoopRunTimedOut;
} else if (__CFRunLoopIsStopped(rl)) {
// RunLoop终止
__CFRunLoopUnsetStopped(rl);
retVal = kCFRunLoopRunStopped;
} else if (rlm->_stopped) {
// mode终止
rlm->_stopped = false;
retVal = kCFRunLoopRunStopped;
} else if (__CFRunLoopModeIsEmpty(rl, rlm, previousMode)) {
retVal = kCFRunLoopRunFinished;
}
...
} while (0 == retVal);
...
return retVal;
}
复制代码
这里盗一张RunLoop运行流程的图:
参考
程序员的自我修养 深入理解RunLoop 苹果文档--RunLoop