大数据

从源码看runLoop

源码比文字更令人深刻

版本: CF-1151.16

官方文档

相关API

源码下载

为了文章简洁,只摘抄部分主要的代码
源码详细介绍在这里

一、邂逅runLoop

应该是一个美丽的下午,在一场面试上,遇见了runLoop,可惜擦肩而过。。。

二、认识runLoop


CFRunLoop

struct __CFRunLoop {
    pthread_t _pthread;                     // runLoop 对应的线程

    __CFPort _wakeUpPort;                // 用来唤醒runLoop的端口,接收消息,执行CFRunLoopWakeUp方法

    CFMutableSetRef _commonModes;       // 集合,所有标记为common的mode的集合

    CFMutableSetRef _commonModeItems;   // 集合,commonMode的item(observers/sources/timers)的集合

    CFRunLoopModeRef _currentMode;      // 当前runLoop运行的mode

    CFMutableSetRef _modes;             // 集合,mode的集合
};

从源码可以看出一部分内容 :
一个runLoop对象,主要包含一个线程_pthread,一个用来被唤醒的端口_wakeUpPort,一个当前运行的mode_currentMode,以及若干个_modes_commonModes_commonModeItems
runLoop有很多mode,即_modes,但是只有一个_currentMode,runLoop一次只能运行在一个mode下,不可能在多个mode下同时运行。

CFRunLoopMode

struct __CFRunLoopMode {
    CFStringRef _name;      // mode的名字,唯一标识

    Boolean _stopped;       // mode的状态,是否停止

    CFMutableSetRef _sources0;  // sources0 的集合

    CFMutableSetRef _sources1;  // sources1 的集合

    CFMutableArrayRef _observers;   // 存储所有观察者(observers)的数组

    CFMutableArrayRef _timers;      // 存储所有定时器(timers)的数组

    // 源码中有一段代码,可以看出字典的存储对象
    // CFDictionarySetValue(rlm->_portToV1SourceMap, (const void *)(uintptr_t)src_port, rls);
    CFMutableDictionaryRef _portToV1SourceMap;  // 字典 key是__CFPort,value是CFRunLoopSourceRef

    // __CFPortSetInsert(src_port, rlm->_portSet);
    __CFPortSet _portSet;           // 端口的集合
}

从mode的组成可以看出来:mode管理了所有的事件(sources/timers/observers),而runLoop是管理mode的

CFRunLoopSource

struct __CFRunLoopSource {
    CFMutableBagRef _runLoops;                 // 一个Source 对应多个runLoop

    union {

        CFRunLoopSourceContext version0;     // source0

        CFRunLoopSourceContext1 version1;     //source1    

    } _context;

}
// source0
typedef struct {
    CFIndex    version;     // 版本号,用来区分是source1还是source0

    void *    info;

    // schedule cancel 是对应的,
    void    (*schedule)(void *info, CFRunLoopRef rl, CFStringRef mode);
    void    (*cancel)(void *info, CFRunLoopRef rl, CFStringRef mode);

    void    (*perform)(void *info); // 用来回调的指针

} CFRunLoopSourceContext;

// source1
typedef struct {
    CFIndex    version;     // 版本号
    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;

源码中看出来,source0和source1的区别,source1比source0多一个接收消息的端口mach_port_t

CFRunLoopObserver

struct __CFRunLoopObserver {

    CFRunLoopRef _runLoop;         // observer对应的runLoop, 一一对应

    CFIndex _rlCount;              //  observer当前监测的runLoop数量,主要在安排/移除runLoop的时候用到

    CFOptionFlags _activities;      // observer观测runLoop的状态,枚举类型,

    CFIndex _order;                 // mode使用数组存储observers,根据_order添加observer

    CFRunLoopObserverCallBack _callout; 
};

_activities状态值:

typedef CF_OPTIONS(CFOptionFlags, CFRunLoopActivity) {
    kCFRunLoopEntry = (1UL << 0),               // 即将进入Loop
    kCFRunLoopBeforeTimers = (1UL << 1),        // runLoop即将处理 Timers
    kCFRunLoopBeforeSources = (1UL << 2),       // runLoop即将处理 Sources
    kCFRunLoopBeforeWaiting = (1UL << 5),       // runLoop即将进入休眠
    kCFRunLoopAfterWaiting = (1UL << 6),        // runLoop刚从休眠中唤醒
    kCFRunLoopExit = (1UL << 7),                // 即将退出RunLoop
    kCFRunLoopAllActivities = 0x0FFFFFFFU       
};

CFRunLoopTimer

struct __CFRunLoopTimer {

    CFRunLoopRef _runLoop;          // timer 对应的runLoop
    CFMutableSetRef _rlModes;       // 集合,存放对应的modes,猜测一个timer 可以有多个modes,即可以被加入到多个modes中

    CFRunLoopTimerCallBack _callout;
};

三、了解runLoop

5个类之间的主要方法,来详细了解类之间的相互关系

CFRunLoopCopyCurrentMode

获取runLoop正在运行的mode(即_currentMode)的name。

CFStringRef CFRunLoopCopyCurrentMode(CFRunLoopRef rl) {

        CFStringRef result = NULL;

       result = (CFStringRef)CFRetain(rl->_currentMode->_name);
        return result;
}

CFRunLoopCopyAllModes

返回一个数组,其中包含了runLoop所有定义过的mode(即_modes)的name

CFArrayRef CFRunLoopCopyAllModes(CFRunLoopRef rl) {

        CFMutableArrayRef array;

        array = CFArrayCreateMutable(kCFAllocatorSystemDefault, CFSetGetCount(rl->_modes), &kCFTypeArrayCallBacks);

        // CFSetApplyFunction 三个参数a,b,c,
        // 表示:对a里面的每个对象,都执行一次b方法,b方法的参数是a和c,后面会多次遇到
        CFSetApplyFunction(rl->_modes, (__CFRunLoopGetModeName), array);

        return array;
}

  // 把mode的name添加进数组array
static void __CFRunLoopGetModeName(const void *value, void *context) {
        CFRunLoopModeRef rlm = (CFRunLoopModeRef)value;
        CFMutableArrayRef array = (CFMutableArrayRef)context;
        CFArrayAppendValue(array, rlm->_name);
}

CFRunLoopAddCommonMode

向runLoop的commonModes添加一个mode

void CFRunLoopAddCommonMode(CFRunLoopRef rl, CFStringRef modeName) {

        // 判断 modeName 是否在_commonModes 中,如果已经存在,else中不做任何处理
        if (!CFSetContainsValue(rl->_commonModes, modeName)) {

            // set 是 runLoop 的 _commonModeItems一份拷贝
            CFSetRef set = rl->_commonModeItems ? CFSetCreateCopy(kCFAllocatorSystemDefault, rl->_commonModeItems) : NULL;
            // 1. _commonModes 添加 modeName,
            // 可见_commonModes存储的其实是CFStringRef类型的modeName
            CFSetAddValue(rl->_commonModes, modeName);

            // 如果items 存在
            if (NULL != set) {
                CFTypeRef context[2] = {rl, modeName};
                // 2. 为modeName对应的Mode添加items中的每个item(timer/source/observer)
                // 为set中的每个item,调用一次__CFRunLoopAddItemsToCommonMode方法
                CFSetApplyFunction(set, (__CFRunLoopAddItemsToCommonMode), (void *)context);
            }
        } else {
        }
}

 // 把一个item添加到指定的mode中
static void __CFRunLoopAddItemsToCommonMode(const void *value, void *ctx) {

        CFTypeRef item = (CFTypeRef)value;

        CFRunLoopRef rl = ()(((CFTypeRef *)ctx)[0]);

        CFStringRef modeName = (CFStringRef)(((CFTypeRef *)ctx)[1]);

        // 判断item具体是哪种类型,然后进行添加
        if (CFGetTypeID(item) == CFRunLoopSourceGetTypeID()) {
            CFRunLoopAddSource(rl, (CFRunLoopSourceRef)item, modeName);
        } else if (CFGetTypeID(item) == CFRunLoopObserverGetTypeID()) {
            CFRunLoopAddObserver(rl, (CFRunLoopObserverRef)item, modeName);
        } else if (CFGetTypeID(item) == CFRunLoopTimerGetTypeID()) {
            CFRunLoopAddTimer(rl, (CFRunLoopTimerRef)item, modeName);
        }
}

CFRunLoopAddSource

添加一个source到指定的runLoopMode

void CFRunLoopAddSource(CFRunLoopRef rl, CFRunLoopSourceRef rls, CFStringRef modeName) {    /* DOES CALLOUT */

        // 声明一个bool值的标识,后续用来source0 添加source
        Boolean doVer0Callout = false;

        // 1. 如果是commonMode,那么commonModes中的所有mode都要更新
        if (modeName == kCFRunLoopCommonModes) {
            /*
            这里获取rl->_commonModes并赋值set,如果没有为NULL
            同时获取rl->_commonModeItems,如果不存在就初始化创建
            */
            // 1.1 先把 rls 添加进_commonModeItems
            CFSetAddValue(rl->_commonModeItems, rls);
            // 1.2 为set中其他的mode,添加rls 
            CFSetApplyFunction(set, (__CFRunLoopAddItemToCommonModes), (void *)context);  

        }
        // 2. 非commonMode的添加 
        else {
            // 2.1 在runLoop的_modes中查找名字为modeName的mode,找不到会在内部进行初始化创建(true决定是否创建)
            CFRunLoopModeRef rlm = __CFRunLoopFindMode(rl, modeName, true);

            // 2.2 获取mode的跟source有关的_sources0,_sources1以及端口_portToV1SourceMap
            if (NULL != rlm && NULL == rlm->_sources0) {
                rlm->_sources0 = CFSetCreateMutable(kCFAllocatorSystemDefault, 0, &kCFTypeSetCallBacks);
                rlm->_sources1 = CFSetCreateMutable(kCFAllocatorSystemDefault, 0, &kCFTypeSetCallBacks);
                rlm->_portToV1SourceMap = CFDictionaryCreateMutable(kCFAllocatorSystemDefault, 0, NULL, NULL);
            }


            // 2.3 判断rls属于哪种类型,并针对性的添加 
            // 2.3.1 source0的情况
            if (0 == rls->_context.version0.version) {
                CFSetAddValue(rlm->_sources0, rls);
                // 下面这段代码是后面的,放在这里便于理解,source0 有个schedule指针,把rl和rlm关联起来
                rls->_context.version0.schedule(rls->_context.version0.info, rl, modeName);
            }
            // 2.3.2 source1的情况 
            else if (1 == rls->_context.version0.version) {
                CFSetAddValue(rlm->_sources1, rls);
                // 获取rls的端口
                __CFPort src_port = rls->_context.version1.getPort(rls->_context.version1.info);
                // rls和端口一一对应,并存储在mode的字典_portToV1SourceMap中
                CFDictionarySetValue(rlm->_portToV1SourceMap, (const void *)(uintptr_t)src_port, rls);
               // 把source1 的端口添加进mode的端口集合_portSet中
                __CFPortSetInsert(src_port, rlm->_portSet);
            }
            // 2.4 把rl 加入到rls的_runLoops中,即一个resources可以对应多个runLoop
            if (NULL == rls->_runLoops) {

                rls->_runLoops = CFBagCreateMutable(kCFAllocatorSystemDefault, 0, &kCFTypeBagCallBacks); // sources retain run loops!
            }
            CFBagAddValue(rls->_runLoops, rl);
       }
}

CFRunLoopAddObserver

添加rlo到指定的rlm

CF_EXPORT void CFRunLoopAddObserver(CFRunLoopRef rl, CFRunLoopObserverRef observer, CFRunLoopMode mode);

内部实现CFRunLoopSource跟差不多,都是根据mode是否commonMode分两种情况,差别在于:

  • 关联mode:mode有一个数组_observers,添加是根据rlo的_order进行添加的

  • 关联rl:根据_rlCount是否为0。只有当rlo的_rlCount为0时,其_runLoop才是rl。

CFRunLoopAddTimer

添加rlt到指定的rlm

CF_EXPORT void CFRunLoopAddTimer(CFRunLoopRef rl, CFRunLoopTimerRef timer, CFRunLoopMode mode);

内部实现同上,区别:

  1. rlt只能添加到其_runLoop的mode中,如果rl不是其_runLoop,直接返回

    if (NULL == rlt->_runLoop) {
            rlt->_runLoop = rl;
        } else if (rl != rlt->_runLoop) {
            __CFRunLoopTimerUnlock(rlt);
            __CFRunLoopModeUnlock(rlm);
            __CFRunLoopUnlock(rl);
            return;
        }
  2. rlt有一个变量_rlModes,其存储的是rlt所在的mode的name

    CFSetAddValue(rlt->_rlModes, rlm->_name);
  3. rlm有一个变量_timers,其存储timer是根据timer的启动时间,即_fireTSR,进行排序的

四、获取runLoop

runLoop跟其所在线程是一一对应的

  1. API提供了两个获取runLoop的方法

    CFRunLoopRef CFRunLoopGetMain(void) {
         static CFRunLoopRef __main = NULL; // no retain needed
    
         // pthread_main_thread_np() 主线程
         if (!__main) __main = _CFRunLoopGet0(pthread_main_thread_np()); // no CAS needed
         return __main;
    }
    
    CFRunLoopRef CFRunLoopGetCurrent(void) {
    
         CFRunLoopRef rl = (CFRunLoopRef)_CFGetTSD(__CFTSDKeyRunLoop);
         if (rl) return rl;
         // pthread_self() 当前线程
         return _CFRunLoopGet0(pthread_self());
     }

    其中,TSD是thread special data,表示线程私有数据,在 C++ 中,全局变量可以被所有线程访问,局部变量只有函数内部可以访问。而 TSD 的作用就是能够在同一个线程的不同函数中被访问。(找到的资料)
    __CFTSDKeyRunLoop是一个枚举类型的关键字。
    pthread_self()可以得知,如果要获取非主线程的runLoop,必须在该线程内部调用CFRunLoopGetCurrent才能获取。

  2. 根据线程t获取对应的runLoop

    // 一个内部全局的字典
    static CFMutableDictionaryRef __CFRunLoops = NULL;
    CF_EXPORT CFRunLoopRef _CFRunLoopGet0(pthread_t t) {
    
         // 1. 保证t不为空       
         if (pthread_equal(t, kNilPthreadT)) {
    
             t = pthread_main_thread_np();
         }
    
         // 2. 创建全局字典,并存储主线程的runLoop
         if (!__CFRunLoops) {
    
             CFMutableDictionaryRef dict = CFDictionaryCreateMutable(kCFAllocatorSystemDefault, 0, NULL, &kCFTypeDictionaryValueCallBacks);
    
             // 通过pthread_main_thread_np()创建CFRunLoopRef类型的mainLoop,内部对其所有变量进行初始化,并且赋值_pthread为pthread_main_thread_np()
             CFRunLoopRef mainLoop = __CFRunLoopCreate(pthread_main_thread_np());
    
             // key是主线程的指针, value 是刚创建的mainLoop
             CFDictionarySetValue(dict, pthreadPointer(pthread_main_thread_np()), mainLoop);
    
             // 比较并交换指针,
             // 这里比较第一个参数NULL和第三个参数 (void * volatile *)&__CFRunLoops全局字典,如果相等,系统会自动把第二参数的值赋给第三个参数,
             // volatile的作用是 每次取得数值的方式是直接从内存中读取
             if (!OSAtomicCompareAndSwapPtrBarrier(NULL, dict, (void * volatile *)&__CFRunLoops)) {
                 CFRelease(dict);
             }
    
             // coreFoundation 要手动管理内存, create 对应 release
             CFRelease(mainLoop);
         }
    
         // 3. 全局字典已经存在,从中获取对应线程t的runLoop
         CFRunLoopRef loop = (CFRunLoopRef)CFDictionaryGetValue(__CFRunLoops, pthreadPointer(t));
    
         // 如果获取不到loop,
         if (!loop) {
    
             // 根据 t 创建 一个newLoop
             CFRunLoopRef newLoop = __CFRunLoopCreate(t);
    
             // 再一次进行获取
             loop = (CFRunLoopRef)CFDictionaryGetValue(__CFRunLoops, pthreadPointer(t));
    
             // 如果还不存在,就直接赋值,
             if (!loop) {
                 CFDictionarySetValue(__CFRunLoops, pthreadPointer(t), newLoop);
                 loop = newLoop;
             }
         }
         // 4. 注册TSD
         if (pthread_equal(t, pthread_self())) {
    
             // 注册回调,当线程销毁时,顺便也销毁其对应的 RunLoop
             _CFSetTSD(__CFTSDKeyRunLoop, (void *)loop, NULL);
    
             if (0 == _CFGetTSD(__CFTSDKeyRunLoopCntr)) {
                 _CFSetTSD(__CFTSDKeyRunLoopCntr, (void *)(PTHREAD_DESTRUCTOR_ITERATIONS-1), (void (*)(void *))__CFFinalizeRunLoop);
             }
         }
         return loop;
    }

    线程和runLoop是一一对应,保存在一个全局字典里,主线程的runLoop是在初始化字典时已经创建好了,其他线程的runLoop只有在获取的时候才会创建。

五、运行runLoop


CFRunLoopRun

默认情况下,运行当前线程的runLoop

void CFRunLoopRun(void) {    
    int32_t result;
    do {
        result = CFRunLoopRunSpecific(CFRunLoopGetCurrent(), kCFRunLoopDefaultMode, 1.0e10, false);
    } while (kCFRunLoopRunStopped != result && kCFRunLoopRunFinished != result);
}

源码得知:

  1. kCFRunLoopDefaultMode,默认情况下,runLoop是在这个mode下运行的,
  2. runLoop的运行主体是一个do..while循环,除非停止或者结束,否则runLoop会一直运行下去

CFRunLoopRunInMode

在指定的mode下运行当前线程的runLoop

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

该方法,可以设置runLoop运行在哪个mode下modeName,超时时间seconds,以及是否处理完事件就返回returnAfterSourceHandled
这两个方法实际调用的是同一个方法CFRunLoopRunSpecific,其返回是一个SInt32类型的值,根据返回值,来决定runLoop的运行状况。

CFRunLoopRunSpecific

在指定的mode下,运行指定的runLoop

SInt32 CFRunLoopRunSpecific(CFRunLoopRef rl, CFStringRef modeName, CFTimeInterval seconds, Boolean returnAfterSourceHandled) {    
    // 根据rl,modeName获取指定的currentMode
    CFRunLoopModeRef currentMode = __CFRunLoopFindMode(rl, modeName, false);

    // 1. 如果当前mode 不存在,或者当前mode中事件为空,runLoop 结束,返回 kCFRunLoopRunFinished
    if (NULL == currentMode || __CFRunLoopModeIsEmpty(rl, currentMode, rl->_currentMode)) {
        // 声明一个标识did,默认false
        Boolean did = false;
        // did 为 false,返回 kCFRunLoopRunFinished
        return did ? kCFRunLoopRunHandledSource : kCFRunLoopRunFinished;
    }

    // 初始化一个返回结果,值为kCFRunLoopRunFinished
    int32_t result = kCFRunLoopRunFinished;

    // 2. kCFRunLoopEntry, 通知observers 即将开始循环
    if (currentMode->_observerMask & kCFRunLoopEntry ) __CFRunLoopDoObservers(rl, currentMode, kCFRunLoopEntry);

    // runLoop运行主体
    result = __CFRunLoopRun(rl, currentMode, seconds, returnAfterSourceHandled, previousMode);

    // 3. kCFRunLoopExit, 通知 observers 即将退出循环runLoop
    if (currentMode->_observerMask & kCFRunLoopExit ) __CFRunLoopDoObservers(rl, currentMode, kCFRunLoopExit);

    return result;
}

这里有3点:

  1. kCFRunLoopRunFinished mode中没有事件处理,直接返回
  2. kCFRunLoopEntry runLoop即将开始运行,通知observers
  3. kCFRunLoopExit runLoop 即将退出,通知observers

__CFRunLoopRun

这里处理了runLoop从开始运行到退出的所有逻辑

static int32_t __CFRunLoopRun(CFRunLoopRef rl, CFRunLoopModeRef rlm, CFTimeInterval seconds, Boolean stopAfterHandle, CFRunLoopModeRef previousMode) {

    // 1. 如果runLoop停止或者runLoopMode为停止状态,直接返回 kCFRunLoopRunStopped
    if (__CFRunLoopIsStopped(rl)) {
        __CFRunLoopUnsetStopped(rl);
        return kCFRunLoopRunStopped;
    } else if (rlm->_stopped) {
    rlm->_stopped = false;
       return kCFRunLoopRunStopped;
    }

    // 获取主线程用来接收消息的端口
    dispatchPort = _dispatch_get_main_queue_port_4CF();

    // 获取执行timers对应的线程的端口
    modeQueuePort = _dispatch_runloop_root_queue_get_port_4CF(rlm->_queue);

    // GCD 管理的定时器,用于实现runLoop的超时机制
    dispatch_source_t timeout_timer = NULL;    
    struct __timeout_context *timeout_context = (struct __timeout_context *)malloc(sizeof(*timeout_context));

    // 处理timer 三种情况 :timer1 立即超时
    if (seconds <= 0.0) { // instant timeout
        seconds = 0.0;
        timeout_context->termTSR = 0ULL;

        // timer2 即将超时
    } else if (seconds <= TIMER_INTERVAL_LIMIT) {
            // 判断在哪个线程中执行
        dispatch_queue_t queue = pthread_main_np() ? __CFDispatchQueueGetGenericMatchingMain() : __CFDispatchQueueGetGenericBackground();

        timeout_timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);

        // 事件一一对应,
        dispatch_source_set_event_handler_f(timeout_timer, __CFRunLoopTimeout);
        dispatch_source_set_cancel_handler_f(timeout_timer, __CFRunLoopTimeoutCancel);
        dispatch_source_set_timer(timeout_timer, dispatch_time(1, ns_at), DISPATCH_TIME_FOREVER, 1000ULL);
        // 定时器执行
        dispatch_resume(timeout_timer);

    } else {
        // timer3 永不超时
        seconds = 9999999999.0;
        timeout_context->termTSR = UINT64_MAX;
    }

    // 声明一个标识,默认true,用于执行消息处理
    Boolean didDispatchPortLastTime = true;
    // 声明一个返回值,用于最后的结果返回
    int32_t retVal = 0;

    // do..while循环主体,处理runLoop的逻辑
    do {

        // 获取rlm的端口集合
        __CFPortSet waitSet = rlm->_portSet;
       // runLoop设置为可被唤醒的状态
        __CFRunLoopUnsetIgnoreWakeUps(rl);

        // 2. kCFRunLoopBeforeTimers runLoop即将处理Timers, 通知observers
        if (rlm->_observerMask & kCFRunLoopBeforeTimers) __CFRunLoopDoObservers(rl, rlm, kCFRunLoopBeforeTimers);
        // 3. kCFRunLoopBeforeSources runLoop即将处理Sources,通知observers
        if (rlm->_observerMask & kCFRunLoopBeforeSources) __CFRunLoopDoObservers(rl, rlm, kCFRunLoopBeforeSources);

        // 4. runLoop开始处理source0事件
        // sourceHandledThisLoop 是否处理完Source0事件
        // 内部实现是,只有被标记Signaled的source0事件才会被处理,但在处理之前会去除标记__CFRunLoopSourceUnsetSignaled
        Boolean sourceHandledThisLoop = __CFRunLoopDoSources0(rl, rlm, stopAfterHandle);

        if (sourceHandledThisLoop) {
            // 处理完Source0之后的回调
            __CFRunLoopDoBlocks(rl, rlm);
        }

        // 处理完source0事件,且没有超时 poll 为false, 
        // 没有处理完source0 事件,或者超时,为true
        Boolean poll = sourceHandledThisLoop || (0ULL == timeout_context->termTSR);

        // didDispatchPortLastTime 初始化为true,即第一次循环的时候不会走if方法,
        // 5. 消息处理,source1 事件,goto 第9步
        if (MACH_PORT_NULL != dispatchPort && !didDispatchPortLastTime) {

            // 从消息缓冲区获取消息
            msg = (mach_msg_header_t *)msg_buffer;
            // dispatchPort收到消息,立刻去处理 
            // dispatchPort 主线程接收消息的端口
            if (__CFRunLoopServiceMachPort(dispatchPort, &msg, sizeof(msg_buffer), &livePort, 0, &voucherState, NULL)) {
                // 收到消息,立马去处理
                goto handle_msg;
            }

            if (__CFRunLoopWaitForMultipleObjects(NULL, &dispatchPort, 0, 0, &livePort, NULL)) {
                goto handle_msg;
            }

        }
        // didDispatchPortLastTime 设置为false,以便进行消息处理
        didDispatchPortLastTime = false;

        // 6. kCFRunLoopBeforeWaiting,通知 observers runLoop即将休眠
        if (!poll && (rlm->_observerMask & kCFRunLoopBeforeWaiting)) __CFRunLoopDoObservers(rl, rlm, kCFRunLoopBeforeWaiting);

        // runLoop 休眠
        __CFRunLoopSetSleeping(rl);

        // 7.线程进入休眠, 直到被下面某一个事件唤醒。(文档给出的结果:)
        // 7.1. 基于 port 的Source1 的事件
        // 7.2. Timer 到时间了
        // 7.3. RunLoop 启动时设置的最大超时时间到了
        // 7.4. 被手动唤醒
        do {
            // 从消息缓冲区获取消息
            msg = (mach_msg_header_t *)msg_buffer;
                // 内部调用 mach_msg() 等待接受 waitSet 的消息
            __CFRunLoopServiceMachPort(waitSet, &msg, sizeof(msg_buffer), &livePort, poll ? 0 : TIMEOUT_INFINITY, &voucherState, &voucherCopy);
        } while (1);

        // 设置rl不再等待唤醒
        __CFRunLoopSetIgnoreWakeUps(rl);
        // runloop 醒来
        __CFRunLoopUnsetSleeping(rl);

        // 8. kCFRunLoopAfterWaiting 已被唤醒,通知observers
       if (!poll && (rlm->_observerMask & kCFRunLoopAfterWaiting)) __CFRunLoopDoObservers(rl, rlm, kCFRunLoopAfterWaiting);

        // 9. 处理消息
        handle_msg:;
        // 设置rl不再等待唤醒
        __CFRunLoopSetIgnoreWakeUps(rl);

        // 判断 livePort
        // 9.1 如果不存在
        if (MACH_PORT_NULL == livePort) {
            CFRUNLOOP_WAKEUP_FOR_NOTHING();
            // 9.2 如果是唤醒rl的端口,回到第2步
        } else if (livePort == rl->_wakeUpPort) {
            CFRUNLOOP_WAKEUP_FOR_WAKEUP();
            ResetEvent(rl->_wakeUpPort);
        }
        // 定时器事件__CFRunLoopDoTimers
        // 9.3 如果是定时器的端口
        else if (modeQueuePort != MACH_PORT_NULL && livePort == modeQueuePort) {
            // 处理定时器事件
            CFRUNLOOP_WAKEUP_FOR_TIMER();
            if (!__CFRunLoopDoTimers(rl, rlm, mach_absolute_time())) {
                __CFArmNextTimerInMode(rlm, rl);
            }
        }
        // 9.4. 如果端口是主线程的端口,直接处理
        else if (livePort == dispatchPort) {
            CFRUNLOOP_WAKEUP_FOR_DISPATCH();
            __CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__(msg);     
        } else {
            // 9.5. 除上述4点之外的端口
            CFRUNLOOP_WAKEUP_FOR_SOURCE();

            // 从端口收到的消息事件,为source1事件
            CFRunLoopSourceRef rls = __CFRunLoopModeFindSourceForMachPort(rl, rlm, livePort);

            if (rls) {

                mach_msg_header_t *reply = NULL;
                        // 处理source1 事件
                sourceHandledThisLoop = __CFRunLoopDoSource1(rl, rlm, rls, msg, msg->msgh_size, &reply) || sourceHandledThisLoop;
                if (NULL != reply) {
                        // 消息处理,
                        // message.h中,以后有时间会再研究一下
                    (void)mach_msg(reply, MACH_SEND_MSG, reply->msgh_size, 0, MACH_PORT_NULL, 0, MACH_PORT_NULL);
                }

            }

        } 
        // 10. 返回结果的处理  
        if (sourceHandledThisLoop && stopAfterHandle) {
            // 10.1 如果事件处理完就返回,并且source处理完成
            retVal = kCFRunLoopRunHandledSource;
        } else if (timeout_context->termTSR < mach_absolute_time()) {
            // 10.2 超时
            retVal = kCFRunLoopRunTimedOut;
        } else if (__CFRunLoopIsStopped(rl)) {
            // 10.3 被外部调用者强制停止了
            __CFRunLoopUnsetStopped(rl);
            retVal = kCFRunLoopRunStopped;
        } else if (rlm->_stopped) {
            // 10.4 runLoopMode 状态停止
            rlm->_stopped = false;
            retVal = kCFRunLoopRunStopped;
        } else if (__CFRunLoopModeIsEmpty(rl, rlm, previousMode)) {
            // 10.5 source/timer/observer一个都没有了
            retVal = kCFRunLoopRunFinished;
        }
        // 上述几种情况,会跳出do..while循环,
        // 除此之外,继续循环
    } while (0 == retVal);
    return retVal;
}

上述2-10就是runLoop运行过程中的循环逻辑,而最终返回的状态有:kCFRunLoopRunFinishedkCFRunLoopRunStoppedkCFRunLoopRunTimedOut以及kCFRunLoopRunHandledSource四种枚举类型

总结:

1. runLoop跟线程一一对应,非主线程的rl只能在其内部获取,runLoop管理rlm和回调block,而rlm存储了所有的事件。

2. runLoop运行核心就是一个do..while循环,遍历所有事件,有事件处理,无事件休眠,直至达到退出条件。

3. 以上就是runLoop内部的源码分析,当然会有理解不到位的情况,也留有待解决的问题,万望不吝赐教。

参考资料:

深入理解RunLoop

RunLoop系列之源码分析

Run Loops

CFRunLoop

发表评论