RunLoop源码阅读RunLoop源码阅读

func loop() {
    repeat {
        var signal = getNextMessage()
        process_message(signal)
    }while signal != quit
}

extern mach_msg_return_t        mach_msg(
    mach_msg_header_t *msg, //消息头
    mach_msg_option_t option,      //消息方式（发送、接受）
    mach_msg_size_t send_size, 
    mach_msg_size_t rcv_size,   //缓冲区域大小，做计算使用
    mach_port_name_t rcv_name,
    mach_msg_timeout_t timeout, //该消息的超时时间，超过这个事件runloop就会进入下次loop或者sleep
    mach_port_name_t notify);   //消息完成后的其他通讯名称
 
 typedef struct{
    mach_msg_bits_t       msgh_bits;    //标示位
    mach_msg_size_t       msgh_size;    //大小
    mach_port_t           msgh_remote_port; //目标端口
    mach_port_t           msgh_local_port;  //源端口
    mach_port_name_t      msgh_voucher_port;
    mach_msg_id_t         msgh_id;
} mach_msg_header_t;

CFRunLoopGetMain(void) //获取主线程的runloop
CFRunLoopGetCurrent(void) //获取当前线程的runloop

CF_EXPORT CFRunLoopRef _CFRunLoopGet0(_CFThreadRef t) {
//如果是当前线程是空的，则获取主线程
    if (pthread_equal(t, kNilPthreadT)) {
    t = pthread_main_thread_np();
    }
//线程锁，防止多个线程读取全局静态字典__CFRunLoops
    __CFLock(&loopsLock);
//如果全局字典为空，在线程创建后就是空值，也就是说线程创建后默认没有runloop
    if (!__CFRunLoops) {
    //创建一个新的临时字典
    CFMutableDictionaryRef dict = CFDictionaryCreateMutable(kCFAllocatorSystemDefault, 0, NULL, &kCFTypeDictionaryValueCallBacks);
    //获取主线程的Runloop，并存到字典中
    CFRunLoopRef mainLoop = __CFRunLoopCreate(pthread_main_thread_np());
    CFDictionarySetValue(dict, pthreadPointer(pthread_main_thread_np()), mainLoop);
    //将临时字典和全局字典做了一次copy操作，并释放临时字典。由于copy操作是临时字典的引用计数+1
    if (!OSAtomicCompareAndSwapPtrBarrier(NULL, dict, (void * volatile *)&__CFRunLoops)) {
        CFRelease(dict);
    }CFRelease(mainLoop);}
    //通过全局字典获取当前线程的runloop
    CFRunLoopRef newLoop = NULL;
    CFRunLoopRef loop = (CFRunLoopRef)CFDictionaryGetValue(__CFRunLoops, pthreadPointer(t));
    //若不存在则创建，并写入全局字典中
    if (!loop) {
    newLoop = __CFRunLoopCreate(t);
        CFDictionarySetValue(__CFRunLoops, pthreadPointer(t), newLoop);
        loop = newLoop;
    }
    __CFUnlock(&loopsLock);
    //2次赋值增加了对应的引用计数
    if (newLoop) { CFRelease(newLoop); }
    
    if (pthread_equal(t, pthread_self())) {
     //把runloop写入当前线程的私有数据中
        _CFSetTSD(__CFTSDKeyRunLoop, (void *)loop, NULL);
        if (0 == _CFGetTSD(__CFTSDKeyRunLoopCntr)) {
        //在线程私有对象中注册一个回调，当线程销毁时将runloop也销毁了
        //__CFFinalizeRunLoop是runloop的析构函数
            _CFSetTSD(__CFTSDKeyRunLoopCntr, (void *)(PTHREAD_DESTRUCTOR_ITERATIONS-1), (void (*)(void *))__CFFinalizeRunLoop);
        }
    }
    return loop;
}

while (alive) {
  performTask()
  callout_to_observer()
  sleep()
}

static void __CFRunLoopDoObservers(CFRunLoopRef rl, CFRunLoopModeRef rlm, CFRunLoopActivity activity)

__CFRunLoopServiceMachPort(::::)

while (alive) {
  //执行任务
  DoBlocks();
  DoMainQueue();
  DoObservers-Sources();
  DoSources0();
  DoSources1();
  DoObservers-Timer();
  DoTimers();
 
  
  //通知外部
  DoObservers-Waiting();
    
  //休眠
  sleep() 
}

//可以通过代码验证一下:
let obs = CFRunLoopObserverCreateWithHandler(kCFAllocatorDefault, CFRunLoopActivity.allActivities.rawValue, true, 0) { (observer, activity) in
            print("Status has changed into: \(activity)")
        }
        CFRunLoopAddObserver(CFRunLoopGetCurrent(), obs, CFRunLoopMode.defaultMode)

struct __CFRunLoop {
    __CFPort _wakeUpPort;//内核向该端口发送消息可以唤醒runloop
    CFMutableSetRef _commonModes;//Set存储的是字符串，记录所有标记为common的mode，标识符
    CFMutableSetRef _commonModeItems; //Set<Source/Observer/Timer>
    CFRunLoopModeRef _currentMode;//当前运行的mode
    CFMutableSetRef _modes;// Set
    ...
};

struct __CFRunLoopMode {
    ...
    CFStringRef _name;
    CFMutableSetRef _sources0;
    CFMutableSetRef _sources1;
    CFMutableArrayRef _observers;
    CFMutableArrayRef _timers;
    ...
};

void CFRunLoopRun(void) {
    int32_t result;
    do {
    //默认在default的modl
        result = CFRunLoopRunSpecific(CFRunLoopGetCurrent(), kCFRunLoopDefaultMode, 1.0e10, false);
        CHECK_FOR_FORK();
    } while (kCFRunLoopRunStopped != result && kCFRunLoopRunFinished != result);
}

//CFRunLoopRef 当前runloop
//CFRunLoopModeRef 当前mode
//seconds 超时唤醒时间
//stopAfterHandle 处理后是否停止
//previousMode 上一次loop的modl
static int32_t __CFRunLoopRun(::::){
//runloop、mode停止，返回停止状态
if (__CFRunLoopIsStopped(rl)) {
    __CFRunLoopUnsetStopped(rl);
return kCFRunLoopRunStopped;
} else if (rlm->_stopped) {
rlm->_stopped = false;
return kCFRunLoopRunStopped;
}
//主端口
__CFPort dispatchPort = CFPORT_NULL;
...
//mode端口
mach_port_name_t modeQueuePort = MACH_PORT_NULL;
...
//唤醒runloop
//在当前线程下创建计时器
//在没有任何msg消息的情况下根据超时时间，超时后唤醒
dispatch_queue_t queue = pthread_main_np() ? __CFDispatchQueueGetGenericMatchingMain() : __CFDispatchQueueGetGenericBackground();
timeout_timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
//设置时间上下线文
dispatch_set_context(timeout_timer, timeout_context);
//时间函数的回调，用来激活runloop
dispatch_source_set_event_handler_f(timeout_timer, __CFRunLoopTimeout);
//时间函数的取消回调
dispatch_source_set_cancel_handler_f(timeout_timer, __CFRunLoopTimeoutCancel);
//只执行一次

//获取当前mode的端口
__CFPortSet waitSet = rlm->_portSet;
//通知Observers，runloop将触发 Before Timer && Source
__CFRunLoopDoObservers(rl, rlm, kCFRunLoopBeforeTimers);
__CFRunLoopDoObservers(rl, rlm, kCFRunLoopBeforeSources);
//执行加入的block
__CFRunLoopDoBlocks(rl, rlm);
//执行Sources0
Boolean sourceHandledThisLoop = __CFRunLoopDoSources0(rl, rlm, stopAfterHandle);
if (sourceHandledThisLoop) {
//执行由Sources0分配来的block
    __CFRunLoopDoBlocks(rl, rlm);
}
//如果有Source1(基于port)处于ready状态，直接处理这个Source1然后跳转去处理消息。
if (MACH_PORT_NULL != dispatchPort && !didDispatchPortLastTime) {
//获取到内核的消息
    msg = (mach_msg_header_t *)msg_buffer;
    if (__CFRunLoopServiceMachPort(dispatchPort, &msg, sizeof(msg_buffer), &livePort, 0, &voucherState, NULL, rl, rlm)) {
        goto handle_msg;
    }}
//通知Observers，runloop即将进入sleep
if (!poll && (rlm->_observerMask & kCFRunLoopBeforeWaiting)) __CFRunLoopDoObservers(rl, rlm, kCFRunLoopBeforeWaiting);
//runloop进入睡眠
    __CFRunLoopSetSleeping(rl);
do{
//通过调用mach_msg，等待接受machPort的消息，但并不处理。线程将进入休眠,直到被下面某一个事件唤醒，或者该runloop被销毁
//__CFRunLoopServiceMachPort相同方法参数不同，分别表示查询到立刻返回和一直等待有消息再返回；将对应port赋值给liveport
msg = (mach_msg_header_t *)msg_buffer;
__CFRunLoopServiceMachPort(waitSet, &msg, sizeof(msg_buffer), &livePort, poll ? 0 : TIMEOUT_INFINITY, &voucherState, &voucherCopy, rl, rlm);
}while{}
//唤醒且开始接受事件
__CFRunLoopSetIgnoreWakeUps(rl);
__CFRunLoopUnsetSleeping(rl);
//接收到某个时间被唤醒runloop被唤醒了
if (!poll && (rlm->_observerMask & kCFRunLoopAfterWaiting)) __CFRunLoopDoObservers(rl, rlm, kCFRunLoopAfterWaiting);
//处理mach_msg消息成功的标签
handle_msg:;
//如果一个Timer到时间了，触发这个Timer的回调, 且重新布置下一次计时器
else if (rlm->_timerPort != MACH_PORT_NULL && livePort == rlm->_timerPort) {
    CFRUNLOOP_WAKEUP_FOR_TIMER();
    if (!__CFRunLoopDoTimers(rl, rlm, mach_absolute_time())) {
            // Re-arm the next timer
        __CFArmNextTimerInMode(rlm, rl);
    }
}
//主端口
else if (livePort == dispatchPort) {
    //通过线程的私有方法里添加gcdMain
    _CFSetTSD(__CFTSDKeyIsInGCDMainQ, (void *)6, NULL);
    //如果有dispatch到main_queue的block,执行block。
    __CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__(msg);
}
//剩余port表示只剩source1，则获取对应source1，或没获取到则抛出异常
CFRunLoopSourceRef rls = __CFRunLoopModeFindSourceForMachPort(rl, rlm, livePort);
//执行对应source1
sourceHandledThisLoop = __CFRunLoopDoSource1(rl, rlm, rls, msg, msg->msgh_size, &reply) || sourceHandledThisLoop;
//创建且销毁source1的对应mach_msg
if (NULL != reply) {
    (void)mach_msg(reply, MACH_SEND_MSG, reply->msgh_size, 0, MACH_PORT_NULL, 0, MACH_PORT_NULL);
    CFAllocatorDeallocate(kCFAllocatorSystemDefault, reply);
}
//执行加入到Loop的block
__CFRunLoopDoBlocks(runloop, currentMode);
//根据参数处理完事件返回
if (sourceHandledThisLoop && stopAfterHandle) {
retVal = kCFRunLoopRunHandledSource;
//超出入参的超时时间
} else if (timeout_context->termTSR < mach_absolute_time()) {
    retVal = kCFRunLoopRunTimedOut;
//runloop被停止
} else if (__CFRunLoopIsStopped(rl)) {
    __CFRunLoopUnsetStopped(rl);
retVal = kCFRunLoopRunStopped;
//mode被停止
} else if (rlm->_stopped) {
rlm->_stopped = false;
retVal = kCFRunLoopRunStopped;
//runloop中没有mode可执行
} else if (__CFRunLoopModeIsEmpty(rl, rlm, previousMode)) {
retVal = kCFRunLoopRunFinished;
}
/// 如果没超时，mode里没空，loop也没被停止，那继续loop。
do『...} while (retVal == 0);
//释放timer