RunLoop底層原理探究

RunLoop 初探

Runloop與線程的關係是一一對應的，一個線程一次只能執行一個任務，任務執行完畢後線程就會被銷燬，而Runloop的做用就是來管理和調度線程是他在沒有任務的時候不會被銷燬。

對於主線程來講，runloop在程序一啓動就默認建立好了。
對於子線程來講，runloop是懶加載的，只有當咱們使用的時候纔會建立

RunLoop運行模式(一共有5種)
Default NSDefaultRunLoopMode (Cocoa) kCFRunLoopDefaultMode(Core Foundation)
Event tracking NSEventTrackingRunLoopMode (Cocoa)
Common modes NSRunLoopCommonModes (Cocoa) kCFRunLoopCommonModes(Core Foundation)

Connection NSConnectionReplyMode (Cocoa)
Modal NSModalPanelRunLoopMode (Cocoa)

5種RunLoop

1. CFRUNLOOP_IS_CALLING_OUT_TO_A_TIMER_CALLBACK_FUNCTION(調用timer，performselector)

2. CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE(GCD主隊列)

3. FBSSERIALQUEUE_IS_CALLING_OUT_TO_A_BLOCK(響應Block)

4. CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION(observer)

5. CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE0_PERFORM_FUNCTION

6. CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE1_PERFORM_FUNCTION

RunLoop與線程的關係

主線程runloop的mode爲Default，Event tracking 是觸摸事件產生的時候，Common modes 是佔位符至關於 NSDefaultRunLoopMode + UITrackingRunLoopMode 。一些定時器的觸摸失效就是由於可能被添加到了默認的Runloop裏面而不是common modes。子線程若是不保證任務執行完不被銷燬也必定要建立一個Runloop來保證線程的存活

RunLoop是一個消息處理機制，系統交給它進行處理各類信息 一個簡單程序執行的過程是 運行->處理計算->完成 -> 結束任務

UIApplication Main的函數註釋是 若是爲PrincipalClassName指定了nil，則使用info.plist中nsPrincipalClass的值。若是沒有指定了nsPrincipalClass鍵，使用了uiApplication類。委託類將使用init進行實例化。因此就到了AppDelegate裏面。一個App啓動的流程

int main(int argc, char * argv[]) {
    @autoreleasepool {

        // If nil is specified for principalClassName, the value for NSPrincipalClass from the Info.plist is used. If there is no
        // NSPrincipalClass key specified, the UIApplication class is used. The delegate class will be instantiated using init.
        return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));;
    }
}
複製代碼

#if DEPLOYMENT_TARGET_WINDOWS || DEPLOYMENT_TARGET_IPHONESIMULATOR
CF_EXPORT pthread_t _CF_pthread_main_thread_np(void);
#define pthread_main_thread_np() _CF_pthread_main_thread_np()
#endif
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;
}
複製代碼

函數中傳入了當前的主線程pthread_main_thread_np在宏定義中定義爲當前主線程主線程進入點進_CFRunLoopGet0b

// should only be called by Foundation
// t==0 is a synonym for "main thread" that always works
CF_EXPORT CFRunLoopRef _CFRunLoopGet0(pthread_t t) {
   /// '判斷當前是不是主線程'
    if (pthread_equal(t, kNilPthreadT)) {
    t = pthread_main_thread_np();
    }
    __CFSpinLock(&loopsLock);
    if (!__CFRunLoops) {
        __CFSpinUnlock(&loopsLock);
    /// '這裏定義了 CFMutableDictionaryRef 創造主Runloop而且將其相關聯 ///這裏達'
    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);
        __CFSpinLock(&loopsLock);
    }
///  '這裏 直接把t指針取出來 拿到runloop 從這能夠看出 線程和Runloop是一一對應的關係 key-- value'
    CFRunLoopRef loop = (CFRunLoopRef)CFDictionaryGetValue(__CFRunLoops, pthreadPointer(t));
    __CFSpinUnlock(&loopsLock);
    if (!loop) {
    CFRunLoopRef newLoop = __CFRunLoopCreate(t);
        __CFSpinLock(&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
        __CFSpinUnlock(&loopsLock);
    CFRelease(newLoop);
    }
    if (pthread_equal(t, pthread_self())) {
        _CFSetTSD(__CFTSDKeyRunLoop, (void *)loop, NULL);
        if (0 == _CFGetTSD(__CFTSDKeyRunLoopCntr)) {
            _CFSetTSD(__CFTSDKeyRunLoopCntr, (void *)(PTHREAD_DESTRUCTOR_ITERATIONS-1), (void (*)(void *))__CFFinalizeRunLoop);
        }
    }
    return loop;
}
複製代碼

從上述代碼能夠看出來 線程和Runloop是一一對應的關係 key-- value 開啓一條子線程裏面執行一個定時器若是Runloop不開啓的時候那麼裏面的計時器是不會執行的從這能夠看出 子線程 Runloop默認不開啓，須要手動開啓

RunLoop 結構

Runloop是個結構體他是一個對象

struct __CFRunLoop {
    CFRuntimeBase _base;
    pthread_mutex_t _lock;          /* locked for accessing mode list */
    __CFPort _wakeUpPort;           // used for CFRunLoopWakeUp 
    Boolean _unused;
    volatile _per_run_data *_perRunData;              // reset for runs of the run loop
    pthread_t _pthread;
    uint32_t _winthread;
    CFMutableSetRef _commonModes; '/// models 集合'
    CFMutableSetRef _commonModeItems; '/// item 是個集合'
    CFRunLoopModeRef _currentMode;  '/// 當前models'
    CFMutableSetRef _modes; '/// models 集合'
    struct _block_item *_blocks_head;
    struct _block_item *_blocks_tail;
    CFTypeRef _counterpart;
};
複製代碼

Model

RunLoop model 的結構

struct __CFRunLoopMode {
    CFRuntimeBase _base;
    pthread_mutex_t _lock;  /* must have the run loop locked before locking this */
    CFStringRef _name;
    Boolean _stopped;
    char _padding[3];
    CFMutableSetRef _sources0;' /// 集合'
    CFMutableSetRef _sources1; '/// 集合'
    CFMutableArrayRef _observers; '/// 數組'
    CFMutableArrayRef _timers; '/// 數組'
    CFMutableDictionaryRef _portToV1SourceMap;
    __CFPortSet _portSet;
    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 USE_MK_TIMER_TOO
    mach_port_t _timerPort;
    Boolean _mkTimerArmed;
#endif
#if DEPLOYMENT_TARGET_WINDOWS
    DWORD _msgQMask;
    void (*_msgPump)(void);
#endif
    uint64_t _timerSoftDeadline; /* TSR */
    uint64_t _timerHardDeadline; /* TSR */
};
複製代碼

RunLoop與model是一對多的關係，他在RunLoop裏是以一個集合的形式存在的。Runloop只能在一個model下運行。可是能夠擁有多個model。

timer

timer在Runloop的model裏面是以數組的形式存在 源碼裏有個關鍵的方法是CFRunLoopRun調用這個方法最後會走到

CFRunLoopRun(CFRunLoopRef rl, CFRunLoopModeRef rlm, CFTimeInterval seconds, Boolean stopAfterHandle, CFRunLoopModeRef previousMode) 這個方法裏會有一個**__CFRunLoopDoBlocks**經過這個方法

static Boolean __CFRunLoopDoBlocks(CFRunLoopRef rl, CFRunLoopModeRef rlm) { // Call with rl and rlm locked
    if (!rl->_blocks_head) return false;
    if (!rlm || !rlm->_name) return false;
    Boolean did = false;
    struct _block_item *head = rl->_blocks_head;
    struct _block_item *tail = rl->_blocks_tail;
    rl->_blocks_head = NULL;
    rl->_blocks_tail = NULL;
    CFSetRef commonModes = rl->_commonModes;
    CFStringRef curMode = rlm->_name;
    __CFRunLoopModeUnlock(rlm);
    __CFRunLoopUnlock(rl);
    struct _block_item *prev = NULL;
    struct _block_item *item = head; "model裏的item以鏈表的形式存在，只要item存在就會一直存在直到爲空爲止。"
    while (item) {
        struct _block_item *curr = item;
        item = item->_next; "訪問鏈表下層，併爲其賦值，"
        Boolean doit = false;
        if (CFStringGetTypeID() == CFGetTypeID(curr->_mode)) {
            "// timer 加入的mode 和 咱們如今runloop的mode 相等 // 或者 curr->_mode = kCFRunLoopCommonModes 相等 // 事務就能執行 timer只要加入到當前model或者commanmodel裏他均可以執行"
            doit = CFEqual(curr->_mode, curMode) || (CFEqual(curr->_mode, kCFRunLoopCommonModes) && CFSetContainsValue(commonModes, curMode));
        } else {
            doit = CFSetContainsValue((CFSetRef)curr->_mode, curMode) || (CFSetContainsValue((CFSetRef)curr->_mode, kCFRunLoopCommonModes) && CFSetContainsValue(commonModes, curMode));
        }
        if (!doit) prev = curr; "若是doit存在則執行響應的block"
        if (doit) { 
            if (prev) prev->_next = item;
            if (curr == head) head = item;
            if (curr == tail) tail = prev;
            void (^block)(void) = curr->_block;
            CFRelease(curr->_mode);
            free(curr);
            if (doit) {
                __CFRUNLOOP_IS_CALLING_OUT_TO_A_BLOCK__(block);"block model的runloop"
                did = true;
            }
            Block_release(block); // do this before relocking to prevent deadlocks where some yahoo wants to run the run loop reentrantly from their dealloc
        }
    }
    __CFRunLoopLock(rl);
    __CFRunLoopModeLock(rlm);
    if (head) {
        tail->_next = rl->_blocks_head;
        rl->_blocks_head = head;
        if (!rl->_blocks_tail) rl->_blocks_tail = tail;
    }
    return did;
}
複製代碼

之因此說是__CFRunLoopDoBlocks是由於最外層會有一個Runloop對一個timer進行添加那咱們看下

RunLoop.current.addtimer()
複製代碼

的底層實現

static void __CFRunLoopAddItemToCommonModes(const void *value, void *ctx) {
    CFStringRef modeName = (CFStringRef)value;
    CFRunLoopRef rl = (CFRunLoopRef)(((CFTypeRef *)ctx)[0]);
    CFTypeRef item = (CFTypeRef)(((CFTypeRef *)ctx)[1]);
    if (CFGetTypeID(item) == CFRunLoopSourceGetTypeID()) {
        CFRunLoopAddSource(rl, (CFRunLoopSourceRef)item, modeName);
    } else if (CFGetTypeID(item) == CFRunLoopObserverGetTypeID()) {
        CFRunLoopAddObserver(rl, (CFRunLoopObserverRef)item, modeName);
    } else if (CFGetTypeID(item) == CFRunLoopTimerGetTypeID()) {"item對應的timerid因此會走這個方法"
        CFRunLoopAddTimer(rl, (CFRunLoopTimerRef)item, modeName);
    }
}


"能夠看到Timer的模式加入到了CFRunLoopAddTimer方法"
void CFRunLoopAddTimer(CFRunLoopRef rl, CFRunLoopTimerRef rlt, CFStringRef modeName) {
    CHECK_FOR_FORK();
    if (__CFRunLoopIsDeallocating(rl)) return;
    if (!__CFIsValid(rlt) || (NULL != rlt->_runLoop && rlt->_runLoop != rl)) return;
    __CFRunLoopLock(rl);
    if (modeName == kCFRunLoopCommonModes) { "若是model是commanmodes的話"
        CFSetRef set = rl->_commonModes ? CFSetCreateCopy(kCFAllocatorSystemDefault, rl->_commonModes) : NULL;
        if (NULL == rl->_commonModeItems) {
            rl->_commonModeItems = CFSetCreateMutable(kCFAllocatorSystemDefault, 0, &kCFTypeSetCallBacks);
        }
        "將timer對象的model設置爲commonmodels ，而後timer加到items裏面去，"
        CFSetAddValue(rl->_commonModeItems, rlt); 
        if (NULL != set) {
            CFTypeRef context[2] = {rl, rlt};
            /* add new item to all common-modes */
            // timer -- items()
            CFSetApplyFunction(set, (__CFRunLoopAddItemToCommonModes), (void *)context);
            CFRelease(set);
        }
    } else {
        CFRunLoopModeRef rlm = __CFRunLoopFindMode(rl, modeName, true);
        if (NULL != rlm) {
            if (NULL == rlm->_timers) {
                CFArrayCallBacks cb = kCFTypeArrayCallBacks;
                cb.equal = NULL;
                rlm->_timers = CFArrayCreateMutable(kCFAllocatorSystemDefault, 0, &cb);
            }
        }
        if (NULL != rlm && !CFSetContainsValue(rlt->_rlModes, rlm->_name)) {
            __CFRunLoopTimerLock(rlt);
            if (NULL == rlt->_runLoop) {
                rlt->_runLoop = rl;
            } else if (rl != rlt->_runLoop) {
                __CFRunLoopTimerUnlock(rlt);
                __CFRunLoopModeUnlock(rlm);
                __CFRunLoopUnlock(rl);
                return;
            }
            CFSetAddValue(rlt->_rlModes, rlm->_name);
            __CFRunLoopTimerUnlock(rlt);
            __CFRunLoopTimerFireTSRLock();
            __CFRepositionTimerInMode(rlm, rlt, false);
            __CFRunLoopTimerFireTSRUnlock();
            if (!_CFExecutableLinkedOnOrAfter(CFSystemVersionLion)) {
                // Normally we don't do this on behalf of clients, but for // backwards compatibility due to the change in timer handling... if (rl != CFRunLoopGetCurrent()) CFRunLoopWakeUp(rl); } } if (NULL != rlm) { __CFRunLoopModeUnlock(rlm); } } __CFRunLoopUnlock(rl); } 複製代碼

這個方法將將timer對象加到items進行調用，而後這裏加了後會在__CFRunLoopDoBlocks裏進行消費(調用)，拿到對應的item，經過doit進行判斷，若是存在則建立一個堆block，引用的對象是timer，而後會進行block的調用。

---

Observer

observer監聽RunLoop的回調狀態，只要Runloop的model改變就會通知RunLoop

Source

Source0

包含函數回調指針 signal待處理 wajeup喚醒RunLoop處理事件，處理app內部事件，app本身負責管理的事物

CFRunLoopSourceContext context = {
        0,
        NULL,
        NULL,
        NULL,
        NULL,
        NULL,
        NULL,
        schedule,
        cancel,
        perform,
    };
    /**
     
     參數一:傳遞NULL或kCFAllocatorDefault以使用當前默認分配器。
     參數二:優先級索引，指示處理運行循環源的順序。這裏我傳0爲了的就是自主回調
     參數三:爲運行循環源保存上下文信息的結構
     */
    CFRunLoopSourceRef source0 = CFRunLoopSourceCreate(CFAllocatorGetDefault(), 0, &context);
    CFRunLoopRef rlp = CFRunLoopGetCurrent();
    // source --> runloop 指定了mode  那麼此時咱們source就進入待緒狀態
    CFRunLoopAddSource(rlp, source0, kCFRunLoopDefaultMode);
    // 一個執行信號
    CFRunLoopSourceSignal(source0);
    // 喚醒 run loop 防止沉睡狀態
    CFRunLoopWakeUp(rlp);
    // 取消 移除
    CFRunLoopRemoveSource(rlp, source0, kCFRunLoopDefaultMode);
    CFRelease(rlp);
複製代碼

Source1

match_port 和 函數回調指針 主要用在線程之間通信

@property (nonatomic, strong) NSPort* subThreadPort;
@property (nonatomic, strong) NSPort* mainThreadPort;

- (void)setupPort{
    self.mainThreadPort = [NSPort port];
    self.mainThreadPort.delegate = self;
    // port - source1 -- runloop
    [[NSRunLoop currentRunLoop] addPort:self.mainThreadPort forMode:NSDefaultRunLoopMode];

    [self task];
}

- (void) task {
    NSThread *thread = [[NSThread alloc] initWithBlock:^{
        self.subThreadPort = [NSPort port];
        self.subThreadPort.delegate = self;
        
        [[NSRunLoop currentRunLoop] addPort:self.subThreadPort forMode:NSDefaultRunLoopMode]; 
        [[NSRunLoop currentRunLoop] run]; "///這裏須要加Run由於子線程Runloop默認不開啓"
    }];
    
    [thread start];
    // 主線 -- 子線程
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"%@", [NSThread currentThread]); // 3

        NSString *str;
        dispatch_async(dispatch_get_main_queue(), ^{
            // 1
            NSLog(@"%@", [NSThread currentThread]);

        });
    });
}

// 線程之間通信
// 主線程 -- data
// 子線程 -- data1
// 更加低層 -- 內核
// mach
- (void)handlePortMessage:(id)message {
    NSLog(@"%@", [NSThread currentThread]); // 3 1

    unsigned int count = 0;
    Ivar *ivars = class_copyIvarList([message class], &count);
    for (int i = 0; i<count; i++) {
        
        NSString *name = [NSString stringWithUTF8String:ivar_getName(ivars[i])];
//        NSLog(@"%@",name);
    }
    
    sleep(1);
    if (![[NSThread currentThread] isMainThread]) {

        NSMutableArray* components = [NSMutableArray array];
        NSData* data = [@"woard" dataUsingEncoding:NSUTF8StringEncoding];
        [components addObject:data];
        "主線程往子線程發送消息"
        [self.mainThreadPort sendBeforeDate:[NSDate date] components:components from:self.subThreadPort reserved:0];
    }
}

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
    
    NSMutableArray* components = [NSMutableArray array];
    NSData* data = [@"hello" dataUsingEncoding:NSUTF8StringEncoding];
    [components addObject:data];
    ///"子線程往主線程發送消息"
    [self.subThreadPort sendBeforeDate:[NSDate date] components:components from:self.mainThreadPort reserved:0];
}
複製代碼

橫線下面爲我歸納總結正在一步一步學習中，下一篇文章將經過RunLoop的源碼進行分析他們是如何實現的

RunLoop總結

Runloop的做用就是來管理和調度線程是他在沒有任務的時候不會被銷燬。
Runloop與線程的關係是一一對應的，一個線程一次只能執行一個任務，任務執行完畢後線程就會被銷燬。對於主線程來講，runloop在程序一啓動就默認建立好了子線程Runloop默認不開啓。
Runloop 與 線程關係是一對一 與mode關係是一對n 意思是同時能夠持有多個model，model裏面分憂、Source、Tiemr、Observer 三中item一樣也是1對多的關係能夠持有多個item，Timer
Observer是以數組的形式存在，而Source 是以集合的形式存在Runloop中。
Source0 的做用是處理app的事物處理 觸摸事件等
Source1 的做用是NSPort 來進行線程通信這種操做偏底層偏內核
observers 的做用是Runloop的model改變的時候會通知Runloop
timer的做用是
Runloop工做的流程是：

1. 通知observer即將進入Runloop
2. 通知Observer將要處理Timer
3. 通知Observer將要處理Source0
4. 處理Source0
5. 若是有Source1調到第9步
6. 通知observer，線程即將進入休眠
7. 休眠等待喚醒(source0，Timer，外部手動喚醒)
8. 通知observer線程剛剛被喚醒
9. 處理Source1，並回到第2步
10. 通知observer將要推出Runloop