OC内存管理-runloop

作者: HotPotCat | 来源:发表于2021-09-18 20:09 被阅读0次

一、runloop 简介

RunLoop是通过内部维护的 事件循环(Event Loop) 来对 事件/消息 进行管理的一个对象。

没有消息处理时，休眠已避免资源占用，由用户态切换到内核态。
有消息需要处理时，立刻被唤醒，由内核态切换到用户态。

image.png

runloop的官方文档在thread篇章Run Loops，也就从侧面说明了runloop是与线程息息相关的。

1.1 runloop 输入源与处理机制

官方有如下一张图：

`runloop`与`source`结构

线程的输入源:

Port Source：基于端口的输入源。
Custom Source：自定义输入源
performSelector：Cocoa执行Selector的源。
Timer Source：定时源。

线程针对输入源的处理机制：

handlePort：处理基于端口的输入源。
customSrc：处理用户自定义输入源。
mySelector：处理Selector的源。
timerFired：处理定时源。

有以下案例：

- (void)sourcesTest {
    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(notificationAction:) name:@"notificationTest" object:nil];
    //__CFRUNLOOP_IS_CALLING_OUT_TO_A_TIMER_CALLBACK_FUNCTION__
    [NSTimer scheduledTimerWithTimeInterval:1 repeats:YES block:^(NSTimer * _Nonnull timer) {
        NSLog(@"timer action");
    }];
    [self performSelector:@selector(performSelectorAction) withObject:nil afterDelay:1.0];
//
//     __CFRUNLOOP_IS_CALLING_OUT_TO_A_BLOCK__
//    __FBSSERIALQUEUE_IS_CALLING_OUT_TO_A_BLOCK__
    void (^block)(void) = ^{
        NSLog(@"block action");
    };
    block();

    // __CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__
    dispatch_async(dispatch_get_main_queue(), ^{
        NSLog(@"main queue");
    });
}

//__CFRUNLOOP_IS_CALLING_OUT_TO_A_TIMER_CALLBACK_FUNCTION__
- (void)performSelectorAction {
    NSLog(@"timer  action");
}

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
    // __CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE0_PERFORM_FUNCTION__
    NSLog(@"touches action");
    [[NSNotificationCenter defaultCenter] postNotificationName:@"notificationTest" object:nil];
}
- (void)notificationAction:(NSNotification *)noti {
    // __CFNOTIFICATIONCENTER_IS_CALLING_OUT_TO_AN_OBSERVER__
    NSLog(@"notification  action");
}

timer与performSelector对应的回调都是__CFRUNLOOP_IS_CALLING_OUT_TO_A_TIMER_CALLBACK_FUNCTION__：

image.png
后续的调用函数不同。

block对应__CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE0_PERFORM_FUNCTION__：

image.png
不过后续调用到了__FBSSERIALQUEUE_IS_CALLING_OUT_TO_A_BLOCK__。

主线程对应__CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__:

image.png

系统触摸事件对应__CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE0_PERFORM_FUNCTION__：

image.png

通知事件对应__CFNOTIFICATIONCENTER_IS_CALLING_OUT_TO_AN_OBSERVER__：

image.png

小结：

调用timer:__CFRUNLOOP_IS_CALLING_OUT_TO_A_TIMER_CALLBACK_FUNCTION__。NSTimer与performSelector都属于timer。
响应source0: __CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE0_PERFORM_FUNCTION__。block，系统触摸事件（触摸事件先交给source1唤醒runloop然后交给source0处理）。
响应source1: __CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE1_PERFORM_FUNCTION__。处理系统事件。
GCD主队列:__CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__。
observer源: __CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__。通知。

二、CFRunloop 的使用

2.1 CFRunLoopMode 验证

- (void)scrollViewDidScroll:(UIScrollView *)scrollView{
    NSLog(@"scrollViewDidScroll: %@",[NSRunLoop currentRunLoop].currentMode);
}

- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView{
    NSLog(@"scrollViewDidEndDecelerating: %@",[NSRunLoop currentRunLoop].currentMode);
}

- (void)runloopModeTest {
    //获取当前runloop
    CFRunLoopRef runloop = CFRunLoopGetCurrent();
    //获取当前mode
    CFRunLoopMode runloopMode  = CFRunLoopCopyCurrentMode(runloop);
    NSLog(@"runloopMode: %@",runloopMode);
    //获取所有 mode
    CFArrayRef modeArray= CFRunLoopCopyAllModes(runloop);
    NSLog(@"modeArray: %@",modeArray);

    NSTimer *timer = [NSTimer timerWithTimeInterval:3 repeats:YES block:^(NSTimer * _Nonnull timer) {
        NSLog(@"timerWithTimeInterval mode: %@",[[NSRunLoop currentRunLoop] currentMode]);
    }];
    //timer 添加到 runloop 的 commonModes
    [[NSRunLoop currentRunLoop] addTimer:timer forMode:NSRunLoopCommonModes];
}

滚动页面输出：

runloopMode: kCFRunLoopDefaultMode
//主线程runloop modes
modeArray: (
    UITrackingRunLoopMode,
    GSEventReceiveRunLoopMode,
    kCFRunLoopDefaultMode,
    kCFRunLoopCommonModes
)
//页面静止
timerWithTimeInterval mode: kCFRunLoopDefaultMode
//页面滚动
scrollViewDidScroll: UITrackingRunLoopMode
scrollViewDidScroll: UITrackingRunLoopMode
timerWithTimeInterval mode: UITrackingRunLoopMode
scrollViewDidScroll: UITrackingRunLoopMode
scrollViewDidEndDecelerating: UITrackingRunLoopMode
//页面静止
timerWithTimeInterval mode: kCFRunLoopDefaultMode

页面滚动过程中处于UITrackingRunLoopMode，静止状态处于kCFRunLoopDefaultMode。

2.2 CFRunLoopTimerRef

@interface ViewController () {
    CFRunLoopTimerRef timerRef;
}
@end

- (void)cfTimerTest {
    /** CFRunLoopTimerContext   timer 上下文
     version: 版本
     info: 传递参数
     void *(*retain)(const void *info): retain 操作
     void    (*release)(const void *info): release 操作
     (*copyDescription)(const void *info): copy 描述信息
     */
    CFRunLoopTimerContext context = {
        0,
        ((__bridge void *)self),
        NULL,
        NULL,
        NULL
    };
    //获取当前 runloop
    CFRunLoopRef runloop = CFRunLoopGetCurrent();

    /** CFRunLoopTimerCreate 创建 timer
     allocator: 用于分配对象的内存
     fireDate：在什么是触发 (距离现在)
     interval: 每隔多少时间触发一次
     flags: 未来参数
     order: CFRunLoopObserver的优先级 当在Runloop同一运行阶段中有多个CFRunLoopObserver 正常情况下使用0
     callout: 回调,比如触发事件。
     context:上下文记录信息
     */
    //创建timer
    timerRef = CFRunLoopTimerCreate(kCFAllocatorDefault, 0, 3, 0, 0, _runLoopTimerCallBack, &context);
    CFRunLoopAddTimer(runloop, timerRef, kCFRunLoopCommonModes);
}

// CFRunLoopTimerCallBack typedef void (*CFRunLoopTimerCallBack)(CFRunLoopTimerRef timer, void *info);
void _runLoopTimerCallBack(CFRunLoopTimerRef timer, void *info) {// info 为 context 中的 info
    NSLog(@"_runLoopTimerCallBack:%@,%@,%@",timer,info,[NSRunLoop currentRunLoop].currentMode);
}

- (void)dealloc {
    [self invalidCFTimer];
}

// 移除 timer
- (void)invalidCFTimer {
    CFRunLoopRef runloop = CFRunLoopGetCurrent();
    if (timerRef && CFRunLoopContainsTimer(runloop, timerRef, kCFRunLoopCommonModes)) {
        CFRunLoopRemoveTimer(runloop, timerRef, kCFRunLoopCommonModes);
    }
}

CFRunLoopTimerContext创建上下文用于传递参数，info就是最终callback回调中的info信息。
CFRunLoopTimerCreate主要是回调函数以及时间间隔的设置。
dealloc中需要移除timer，不释放有可能crash，不会造成循环引用。需要判断timer是否存在以及是否在要移除的runloop中。

2.3 CFRunLoopObserverRef

CFRunLoopObserverRef observerRef;

- (void)cfObserverTest {
    //context 与 timer 的相同
    CFRunLoopObserverContext context = {
        0,
        ((__bridge void *)self),
        NULL,
        NULL,
        NULL
    };
    CFRunLoopRef runloop = CFRunLoopGetCurrent();

    /**
     allocator: 用于分配对象的内存
     activities: 要关注的事件，与 runloop 循环中处理的状态一致。
         typedef CF_OPTIONS(CFOptionFlags, CFRunLoopActivity) {
             kCFRunLoopEntry = (1UL << 0),
             kCFRunLoopBeforeTimers = (1UL << 1),
             kCFRunLoopBeforeSources = (1UL << 2),
             kCFRunLoopBeforeWaiting = (1UL << 5),
             kCFRunLoopAfterWaiting = (1UL << 6),
             kCFRunLoopExit = (1UL << 7),
             kCFRunLoopAllActivities = 0x0FFFFFFFU
         };
     repeats: CFRunLoopObserver 是否循环调用，不循环只会有一次回调。NO的情况下 CFRunLoopObserverRef 会自动移除。
     order: CFRunLoopObserver 的优先级 当在Runloop同一运行阶段中有多个 CFRunLoopObserver 正常情况下使用 0
     callout: 回调
     context: 上下文记录信息
     */
    observerRef = CFRunLoopObserverCreate(kCFAllocatorDefault, kCFRunLoopAllActivities, NO, 0, _runLoopObserverCallBack, &context);
    CFRunLoopAddObserver(runloop, observerRef, kCFRunLoopDefaultMode);
}

//typedef void (*CFRunLoopObserverCallBack)(CFRunLoopObserverRef observer, CFRunLoopActivity activity, void *info);
void _runLoopObserverCallBack(CFRunLoopObserverRef observer, CFRunLoopActivity activity, void *info){
    NSLog(@"observerCallBack: %@,%lu,%@",observer,activity,info);
}

- (void)removeRunloopObserver {
    CFRunLoopRef runloop = CFRunLoopGetCurrent();
    if (observerRef && CFRunLoopContainsObserver(runloop, observerRef, kCFRunLoopDefaultMode)) {
        CFRunLoopRemoveObserver(runloop, observerRef, kCFRunLoopDefaultMode);
    }
}

- (void)dealloc {
    [self removeRunloopObserver];
}

CFRunLoopObserverContext与CFRunLoopTimerContext结构相同。
CFRunLoopObserverCreate可以只监听某些状态。
- repeats控制是否循环调用，不循环的情况下回调只会调用一次（所有状态假加起来），并且会自动从runloop中移除。

可以通过observer进行卡顿检测相关逻辑处理。

2.4 CFRunLoopSourceRef

2.4.1 source0

- (void)source0Test {
    /**
     typedef struct {
         CFIndex    version; //版本
         void *    info; //回调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); //hash code
         void    (*schedule)(void *info, CFRunLoopRef rl, CFRunLoopMode mode); //准备代发回调
         void    (*cancel)(void *info, CFRunLoopRef rl, CFRunLoopMode mode); //取消回调
         void    (*perform)(void *info); // 执行回调
     } CFRunLoopSourceContext;
     */
    CFRunLoopSourceContext context = {
        0,
        NULL,
        NULL,
        NULL,
        NULL,
        NULL,
        NULL,
        schedule,
        cancel,
        perform,
    };

    /**
     allocator: 传递NULL或 kCFAllocatorDefault 以使用当前默认分配器。
     order: 优先级索引，指示处理运行循环源的顺序。这里传0为了的就是自主回调
     context: 为运行循环源保存上下文信息的结构
     */
    //创建source
    CFRunLoopSourceRef source0 = CFRunLoopSourceCreate(CFAllocatorGetDefault(), 0, &context);
    CFRunLoopRef runloop = CFRunLoopGetCurrent();
    //source 指定了 runloop 与 mode 就进去就绪状态了。schedule 调用
    CFRunLoopAddSource(runloop, source0, kCFRunLoopDefaultMode);
    //一个执行信号 perform
    CFRunLoopSourceSignal(source0);
    //这里加延迟为了让 perform 有机会执行。
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        //唤醒 runloop 防止沉睡状态
        CFRunLoopWakeUp(runloop);
        //取消移除 source，执行 cancel 回调
        CFRunLoopRemoveSource(runloop, source0, kCFRunLoopDefaultMode);
    });
}

void schedule(void *info, CFRunLoopRef rl, CFRunLoopMode mode){
    NSLog(@"schedule 准备代发");
}

void perform(void *info){
    NSLog(@"source0 执行");
}

void cancel(void *info, CFRunLoopRef rl, CFRunLoopMode mode){
    NSLog(@"source0 cancel");
}

输出：

schedule 准备代发
source0 执行
source0 cancel

CFRunLoopSourceContext相比timer和observer多了判等以及哈希相关计算外。更重要的是schedule 、cancel 、perform 3个回调。
CFRunLoopSourceCreate相比就比较简单了，重要参数是context。

2.4.2 source1 线程间通信

@interface ViewController ()<NSPortDelegate> 

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

@end

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

- (void)task {
    __weak typeof(self) weakSelf = self;
    NSThread *thread = [[NSThread alloc] initWithBlock:^{
        NSLog(@"initWithBlock:%@", [NSThread currentThread]); // 5
        weakSelf.subThreadPort = [NSPort port];
        weakSelf.subThreadPort.delegate = weakSelf;
        [[NSRunLoop currentRunLoop] addPort:weakSelf.subThreadPort forMode:NSDefaultRunLoopMode];
        [[NSRunLoop currentRunLoop] run];
    }];
    [thread start];
}

#pragma mark --- NSPortDelegate ---
- (void)handlePortMessage:(id)message {//NSPortMessage 是macos中的类。
    NSLog(@"handlePortMessage: %@, thread:%@",message,[NSThread currentThread]);
    NSArray *componentsArray = [message valueForKey:@"components"];
    for (NSInteger i = 0; i < componentsArray.count; i++) {
        NSData *data = componentsArray[i];
        NSString *dataStr = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
        NSLog(@"dataStr: %@",dataStr);
    }
    
    //runtime 获取ivar。
//    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(@"data: %@",name);
//    }
    
    sleep(1);
    if (![[NSThread currentThread] isMainThread]) {
        NSMutableArray *components = [NSMutableArray array];
        //必须转成data，否则会被忽略。
        NSData *data = [@"hotpot" dataUsingEncoding:NSUTF8StringEncoding];
        [components addObject:data];
        //从 subport 给 mainport 发送数据。
        NSLog(@"mainport send data to subport");
        [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 = [@"cat" dataUsingEncoding:NSUTF8StringEncoding];
    [components addObject:data];
    //从 mainport 给 subThreadPort 发送数据。
    NSLog(@"subport send data to mainport");
    [self.subThreadPort sendBeforeDate:[NSDate date] components:components from:self.mainThreadPort reserved:0];
}

输出：

image.png

mainThreadPort是在主线程创建添加进runloop的，subThreadPort是在子线程创建添加进runloop的。
handlePortMessage :为NSPortDelegate的代理方法。参数NSPortMessage是定义在macOS中的。iOS没有该类的定义。
通过sendBeforeDate:components:from: reserved :进行线程间数据传递。从from port给调用方port线程发送数据。
数据需要包装为NSData才有效。

NSPortMessage定义在macOS中：

image.png

三、runloop 结构

既然runloop是一个事件循环，那么它与普通的循环有什么区别呢？
普通循环：

image.png

runloop循环：

image.png

那么可以得到以下结论：

runloop能保持程序的持续运行。
处理APP中的各种事件(触摸、定时器、performSelector)。
节省cpu资源、提高程序的性能。有休眠和唤醒状态。

3.1 runloop 源码定位

那么runloop是怎么做到的呢？
通常我们会通过NSRunLoop去获取当前的runloop：

[NSRunLoop currentRunLoop];

定义如下：

@property (class, readonly, strong) NSRunLoop *currentRunLoop;

给currentRunLoop下符号断点：

image.png
可以看到NSRunLoop是对CFRunLoop的封装。

image.png

通过之前的分析已经定位到了runloop是在CoreFoundation中的 CoreFoundation源码。正好CoreFoundation开源了CFRunLoop：

image.png

3.2 CFRunLoopRun

//CFRunLoopRun 是对 do...while 的封装
void CFRunLoopRun(void) {    /* DOES CALLOUT */
    int32_t result;
    do {
        //run
        result = CFRunLoopRunSpecific(CFRunLoopGetCurrent(), kCFRunLoopDefaultMode, 1.0e10, false);
        CHECK_FOR_FORK();
        //不是完成或者结束
    } while (kCFRunLoopRunStopped != result && kCFRunLoopRunFinished != result);
}

runloop底层是对do...while的封装。
当状态为完成或者结束后退出循环。

那么核心逻辑就在CFRunLoopRunSpecific中。还有一个疑问是runloop可以休眠，那么它是如何实现的呢？

3.3 runloop 数据结构

要了解runloop的实现原理，首先要清楚它的数据结构。

3.3.1 线程与runloop的关系

CFRunLoopRunSpecific的第一个参数是CFRunLoopGetCurrent()：

CFRunLoopRef CFRunLoopGetCurrent(void) {
    CHECK_FOR_FORK();
    //通过 key-value 形式获取 CFRunLoopRef
    CFRunLoopRef rl = (CFRunLoopRef)_CFGetTSD(__CFTSDKeyRunLoop);
    if (rl) return rl;
    //没有缓存通过线程获取
    return _CFRunLoopGet0(pthread_self());
}

去缓存中获取CFRunLoopRef。
缓存中不存在通过线程去获取。

_CFRunLoopGet0

// should only be called by Foundation
// t==0 is a synonym for "main thread" that always works
CF_EXPORT CFRunLoopRef _CFRunLoopGet0(pthread_t t) {
    //没有传 pthread_t，则默认为主线程
    if (pthread_equal(t, kNilPthreadT)) {
        t = pthread_main_thread_np();
    }
    __CFLock(&loopsLock);
    if (!__CFRunLoops) {
        __CFUnlock(&loopsLock);
    //创建可变字典
    CFMutableDictionaryRef dict = CFDictionaryCreateMutable(kCFAllocatorSystemDefault, 0, NULL, &kCFTypeDictionaryValueCallBacks);
        
    //通过 主线程 创建 mainLoop
    CFRunLoopRef mainLoop = __CFRunLoopCreate(pthread_main_thread_np());
        
    // 进行绑定，存储 thread（key） - runloop（value）: dict[@"pthread_main_thread_np"] = mainLoop
    CFDictionarySetValue(dict, pthreadPointer(pthread_main_thread_np()), mainLoop);
        
        
    if (!OSAtomicCompareAndSwapPtrBarrier(NULL, dict, (void * volatile *)&__CFRunLoops)) {
        CFRelease(dict);
    }
    CFRelease(mainLoop);
        __CFLock(&loopsLock);
    }
    //通过 thread 获取 runloop（非main runloop）
    CFRunLoopRef loop = (CFRunLoopRef)CFDictionaryGetValue(__CFRunLoops, pthreadPointer(t));
    __CFUnlock(&loopsLock);
    if (!loop) {//runloop不存在
        //创建runloop
    CFRunLoopRef newLoop = __CFRunLoopCreate(t);
        __CFLock(&loopsLock);
    loop = (CFRunLoopRef)CFDictionaryGetValue(__CFRunLoops, pthreadPointer(t));
    if (!loop) {
        //存储 runloop
        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);
    }
    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与线程是一一对应的，每个runloop对应一个线程。线程并不一定有runloop，在有的情况下是一一对应的。
runloop底层是存储在可变字典中的，key为线程，value为runloop。
runloop是CFRunLoopRef类型，通过__CFRunLoopCreate创建。

image.png

3.3.2 CFRunLoopRef

image.png
可以看到在创建CFRunLoopRef的时候有对应的modes、items、_pthread。并且创建完成后调用__CFRunLoopFindMode去找mode。

CFRunLoopRef的定义如下：

typedef struct CF_BRIDGED_MUTABLE_TYPE(id) __CFRunLoop * CFRunLoopRef;

实际上底层它是__CFRunLoop类型：

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;
    CFMutableSetRef _commonModeItems;//集合类型 Items
    CFRunLoopModeRef _currentMode;
    CFMutableSetRef _modes;//集合类型 Modes
    struct _block_item *_blocks_head;
    struct _block_item *_blocks_tail;
    CFAbsoluteTime _runTime;
    CFAbsoluteTime _sleepTime;
    CFTypeRef _counterpart;
};

一个runloop对应多个modes以及items。

对于timer而言:

[[NSRunLoop currentRunLoop] addTimer:<#(nonnull NSTimer *)#> forMode:<#(nonnull NSRunLoopMode)#>];

显然它是要依赖mode的。

CFRunLoopMode

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;//set source0
    CFMutableSetRef _sources1;//set source1
    CFMutableArrayRef _observers;//array observe
    CFMutableArrayRef _timers;//array times
    CFMutableDictionaryRef _portToV1SourceMap;//dic port
    __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 */
};

而一个mode下又对应多个items(source0、source1、timers、observers)，所以就有如下关系：

image.png

1个runloop对应1个线程。
1个runloop对应多个mode。
1个mode对应多个source、timer、observer。

3.3.3 RunLoop Modes

既然有多种mode，那么都有哪些呢？
源码中有如下定义：

CF_EXPORT const CFRunLoopMode kCFRunLoopDefaultMode;
CF_EXPORT const CFRunLoopMode kCFRunLoopCommonModes;

它们对应Foundation中的：

FOUNDATION_EXPORT NSRunLoopMode const NSDefaultRunLoopMode;
FOUNDATION_EXPORT NSRunLoopMode const NSRunLoopCommonModes ;

我们都清楚在页面滚动的时候有一个UITrackingRunLoopMode：

UIKIT_EXTERN NSRunLoopMode const UITrackingRunLoopMode;

除了以上3种mode还有两个私有mode：

UIInitializationRunLoopMode
GSEventReceiveRunLoopMode

当RunLoop运行在Mode1上时，是无法接受处理Mode2或Mode3上的Source、Timer、Observer事件的。

kCFRunLoopDefaultMode/NSDefaultRunLoopMode：默认模式，主线程是在这个运行模式下运行。
kCFRunLoopCommonModes/NSRunLoopCommonModes：伪模式，不是一种真正的运行模式，是同步Source/Timer/Observer到多个Mode中。
UITrackingRunLoopMode：跟踪用户交互事件（用于 ScrollView追踪触摸滑动，保证界面滑动时不受其他Mode影响）。对于macOS对应NSEventTrackingRunLoopMode
UIInitializationRunLoopMode：在刚启动App时第进入的第一个 Mode，启动完成后就不再使用。
GSEventReceiveRunLoopMode：接受系统内部事件，通常用不到。

四、runloop 事务处理

4.1 timer 事务处理

以timer为例，将timer加入到runloop中：

NSTimer *timer = [NSTimer timerWithTimeInterval:1 repeats:YES block:^(NSTimer * _Nonnull timer) {
    NSLog(@"timerWithTimeInterval block -- %@",[[NSRunLoop currentRunLoop] currentMode]);
}];
[[NSRunLoop currentRunLoop] addTimer:timer forMode:NSRunLoopCommonModes];

底层调用了CFRunLoopAddTimer：

image.png

4.1.1 CFRunLoopAddTimer

//runloop  timer  mode
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);
    
    //kCFRunLoopCommonModes 集合mode
    if (modeName == kCFRunLoopCommonModes) {
        CFSetRef set = rl->_commonModes ? CFSetCreateCopy(kCFAllocatorSystemDefault, rl->_commonModes) : NULL;
        if (NULL == rl->_commonModeItems) {
            rl->_commonModeItems = CFSetCreateMutable(kCFAllocatorSystemDefault, 0, &kCFTypeSetCallBacks);
        }
        //将 timer 加入 modeItems 中。
        CFSetAddValue(rl->_commonModeItems, rlt);
        if (NULL != set) {
            CFTypeRef context[2] = {rl, rlt};
            /* add new item to all common-modes */
            //加入所有的command modes 中。
            CFSetApplyFunction(set, (__CFRunLoopAddItemToCommonModes), (void *)context);
            CFRelease(set);
        }
    } else {//非common mode
        //从 runloop 中找到对应的 mode
        CFRunLoopModeRef rlm = __CFRunLoopFindMode(rl, modeName, true);
        if (NULL != rlm) {//mode存在
            if (NULL == rlm->_timers) {//不存在timer
                CFArrayCallBacks cb = kCFTypeArrayCallBacks;
                cb.equal = NULL;
                //创建timer
                rlm->_timers = CFArrayCreateMutable(kCFAllocatorSystemDefault, 0, &cb);
            }
        }
        if (NULL != rlm && !CFSetContainsValue(rlt->_rlModes, rlm->_name)) {
            __CFRunLoopTimerLock(rlt);
            //timer没有runloop
            if (NULL == rlt->_runLoop) {
                //设置runloop
                rlt->_runLoop = rl;
            } else if (rl != rlt->_runLoop) {//timer所有的runloop与当前runloop不同直接返回。
                __CFRunLoopTimerUnlock(rlt);
                __CFRunLoopModeUnlock(rlm);
                __CFRunLoopUnlock(rl);
                return;
            }
            //将timer 加入 mode中。
            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...
                //唤醒runloop
                if (rl != CFRunLoopGetCurrent()) CFRunLoopWakeUp(rl);
            }
        }
        if (NULL != rlm) {
            __CFRunLoopModeUnlock(rlm);
        }
    }
   
    __CFRunLoopUnlock(rl);
}

根据要加入的mode区分是common mode和非common mode将timer加入mode中。这个时候只是将timer加入了mode中，要执行肯定要调用CFRunLoopRun，最终要调用CFRunLoopRunSpecific。

4.1.2 CFRunLoopRunSpecific

CFRunLoopRunSpecific(CFRunLoopGetCurrent(), kCFRunLoopDefaultMode, 1.0e10, false);

//对应声明
SInt32 CFRunLoopRunSpecific(CFRunLoopRef rl, CFStringRef modeName, CFTimeInterval seconds, Boolean returnAfterSourceHandled)

CFRunLoopGetCurrent()创建runloop。
mode默认给的是kCFRunLoopDefaultMode。
1.0e10（1 * 10¹⁰）表示超时时间。
returnAfterSourceHandled表示source处理后是否返回。

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;
    
    if (currentMode->_observerMask & kCFRunLoopEntry )
        // 1. 通知 Observers: RunLoop 即将进入 loop。
        __CFRunLoopDoObservers(rl, currentMode, kCFRunLoopEntry);
        //run
    result = __CFRunLoopRun(rl, currentMode, seconds, returnAfterSourceHandled, previousMode);
    if (currentMode->_observerMask & kCFRunLoopExit )
        // 10. 通知 Observers: RunLoop 即将退出。
        __CFRunLoopDoObservers(rl, currentMode, kCFRunLoopExit);
    
    __CFRunLoopModeUnlock(currentMode);
    __CFRunLoopPopPerRunData(rl, previousPerRun);
    rl->_currentMode = previousMode;
    __CFRunLoopUnlock(rl);
    return result;
}

根据modeName找到本次运行的mode。
1.通知 Observers RunLoop即将进入 loop。
调用__CFRunLoopRun运行循环。
10.通知 Observers RunLoop 即将退出。

4.1.3 __CFRunLoopRun

在__CFRunLoopRun中调用了__CFRunLoopDoTimers：

// rl and rlm are locked on entry and exit
static Boolean __CFRunLoopDoTimers(CFRunLoopRef rl, CFRunLoopModeRef rlm, uint64_t limitTSR) {    /* DOES CALLOUT */
    Boolean timerHandled = false;
    CFMutableArrayRef timers = NULL;
    //从mode中获取timers进行处理
    for (CFIndex idx = 0, cnt = rlm->_timers ? CFArrayGetCount(rlm->_timers) : 0; idx < cnt; idx++) {
        CFRunLoopTimerRef rlt = (CFRunLoopTimerRef)CFArrayGetValueAtIndex(rlm->_timers, idx);
        
        if (__CFIsValid(rlt) && !__CFRunLoopTimerIsFiring(rlt)) {
            if (rlt->_fireTSR <= limitTSR) {
                if (!timers) timers = CFArrayCreateMutable(kCFAllocatorSystemDefault, 0, &kCFTypeArrayCallBacks);
                CFArrayAppendValue(timers, rlt);
            }
        }
    }
    
    for (CFIndex idx = 0, cnt = timers ? CFArrayGetCount(timers) : 0; idx < cnt; idx++) {
        CFRunLoopTimerRef rlt = (CFRunLoopTimerRef)CFArrayGetValueAtIndex(timers, idx);
        //执行timer
        Boolean did = __CFRunLoopDoTimer(rl, rlm, rlt);
        timerHandled = timerHandled || did;
    }
    if (timers) CFRelease(timers);
    return timerHandled;
}

找到mode中的所有timer然后调用__CFRunLoopDoTimer。

4.1.4 __CFRunLoopDoTimer

image.png
在__CFRunLoopDoTimer中进行了时间的判断以及timer回调的调用并且重新计算了_fireTSR。这样整个调用流程就与回调堆栈吻合了。

CFRunLoopAddTimer -> CFRunLoopRunSpecific -> __CFRunLoopRun -> __CFRunLoopDoTimers -> __CFRunLoopDoTimer -> __CFRUNLOOP_IS_CALLING_OUT_TO_A_TIMER_CALLBACK_FUNCTION__。

4.2 source 事务处理

与timer相同source会调用CFRunLoopAddSource：

image.png
将source加入mode中。同样调用是在__CFRunLoopRun中。

4.2.1 __CFRunLoopDoSources0

image.png
在__CFRunLoopDoSources0中调用了__CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE0_PERFORM_FUNCTION__。

4.2.2 __CFRunLoopDoSources1

image.png
__CFRunLoopDoSources1最终调用了__CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE1_PERFORM_FUNCTION__

CFRunLoopAddSource -> CFRunLoopRunSpecific -> __CFRunLoopRun -> __CFRunLoopDoSources0/__CFRunLoopDoSources1 -> __CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE0_PERFORM_FUNCTION__ /__CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE1_PERFORM_FUNCTION__

4.3 observer 事务处理

同理observer会调用CFRunLoopAddObserver。

4.3.1 CFRunLoopAddObserver

image.png
将observer加入_observers或者_commonModeItems中。同样调用是在__CFRunLoopRun中。

4.3.2 __CFRunLoopDoObservers

image.png
__CFRunLoopDoObservers最终调用__CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__传递了状态参数。

CFRunLoopAddObserver -> CFRunLoopRunSpecific -> __CFRunLoopRun -> __CFRunLoopDoObservers(状态参数) -> __CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__(状态参数)

4.4 回调函数

4.4.1 CFRUNLOOP_IS_CALLING_OUT_TO_A_TIMER_CALLBACK_FUNCTION

static void __CFRUNLOOP_IS_CALLING_OUT_TO_A_TIMER_CALLBACK_FUNCTION__() __attribute__((noinline));
static void __CFRUNLOOP_IS_CALLING_OUT_TO_A_TIMER_CALLBACK_FUNCTION__(CFRunLoopTimerCallBack func, CFRunLoopTimerRef timer, void *info) {
    if (func) {
        func(timer, info);
    }
    asm __volatile__(""); // thwart tail-call optimization
}

timer直接调用回调函数，传递timer参数。

4.4.2 CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE0_PERFORM_FUNCTION

static void __CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE0_PERFORM_FUNCTION__() __attribute__((noinline));
static void __CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE0_PERFORM_FUNCTION__(void (*perform)(void *), void *info) {
    if (perform) {
        perform(info);
    }
    asm __volatile__(""); // thwart tail-call optimization
}

source0直接调用perform。

4.4.3 CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE1_PERFORM_FUNCTION

static void __CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE1_PERFORM_FUNCTION__() __attribute__((noinline));
static void __CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE1_PERFORM_FUNCTION__(
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
        void *(*perform)(void *msg, CFIndex size, CFAllocatorRef allocator, void *info),
        mach_msg_header_t *msg, CFIndex size, mach_msg_header_t **reply,
#else
        void (*perform)(void *),
#endif
        void *info) {
    if (perform) {
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
        *reply = perform(msg, size, kCFAllocatorSystemDefault, info);
#else
        perform(info);
#endif
    }
    asm __volatile__(""); // thwart tail-call optimization
}

source1不同架构处理不同，iOS上与source0处理相同。

4.4.4 CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION

static void __CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__() __attribute__((noinline));
static void __CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__(CFRunLoopObserverCallBack func, CFRunLoopObserverRef observer, CFRunLoopActivity activity, void *info) {
    if (func) {
        func(observer, activity, info);
    }
    asm __volatile__(""); // thwart tail-call optimization
}

observer调用回调函数其中传递了activity状态参数。

4.4.5 CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE

static void __CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__() __attribute__((noinline));
static void __CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__(void *msg) {
    _dispatch_main_queue_callback_4CF(msg);
    asm __volatile__(""); // thwart tail-call optimization
}

直接调用_dispatch_main_queue_callback_4CF。

4.5.6 source1 与 source0

点击触摸事件会先调用source1：

image.png

然后交给source0处理：

image.png
之后才会进入触摸回调。

系统先通过source1唤醒runloop然后交给source0处理事件。

五、runloop 原理

在CFRunLoopRun的过程中do...while的条件是根据返回的状态判断的：

enum {
    kCFRunLoopRunFinished = 1,//完成
    kCFRunLoopRunStopped = 2,//结束
    kCFRunLoopRunTimedOut = 3,//超时
    kCFRunLoopRunHandledSource = 4//处理完source
};

在CFRunLoopRunSpecific的过程中也有状态的切换：

/* Run Loop Observer Activities */
typedef CF_OPTIONS(CFOptionFlags, CFRunLoopActivity) {
    kCFRunLoopEntry = (1UL << 0),//启动
    kCFRunLoopBeforeTimers = (1UL << 1),//将要处理 timer 事件
    kCFRunLoopBeforeSources = (1UL << 2),//将要处理 Source 事件
    kCFRunLoopBeforeWaiting = (1UL << 5),//将要进入休眠状态,即将由用户态切换到内核态
    kCFRunLoopAfterWaiting = (1UL << 6),//被唤醒，即从内核态切换到用户态后
    kCFRunLoopExit = (1UL << 7),//退出
    kCFRunLoopAllActivities = 0x0FFFFFFFU //监听所有状态
};

可以通过CFRunLoopActivity监听整个runloop的生命周期。

runloop的整个核心逻辑就在__CFRunLoopRun中：

image.png

整个流程伪代码如下：

//获取 mode 处理
SInt32 CFRunLoopRunSpecific(CFRunLoopRef rl, CFStringRef modeName, CFTimeInterval seconds, Boolean returnAfterSourceHandled) {  
    /// 首先根据modeName找到对应mode
    CFRunLoopModeRef currentMode = __CFRunLoopFindMode(rl, modeName, false);
    
    /// 1.通知 Observers: RunLoop 即将进入 loop。
    __CFRunLoopDoObservers(rl, currentMode, kCFRunLoopEntry);
    
    /// 内部函数，进入loop
    result = __CFRunLoopRun(rl, currentMode, seconds, returnAfterSourceHandled, previousMode);
    
    /// 10.通知 Observers: RunLoop 即将退出。
    __CFRunLoopDoObservers(rl, currentMode, kCFRunLoopExit);
    
    return result;
}

//核心函数
/**
 *  运行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) {
    
    //一些超时逻辑相关的处理

    int32_t retVal = 0;
    
    do {  //itmes do
        
        /// 2. 通知 Observers: 即将处理timer事件
        __CFRunLoopDoObservers(rl, rlm, kCFRunLoopBeforeTimers);
        
        /// 3.通知 Observers: 即将处理Source0（非port）事件
        __CFRunLoopDoObservers(rl, rlm, kCFRunLoopBeforeSources)
        
        /// 执行被加入的 block
        __CFRunLoopDoBlocks(rl, rlm);
        
        /// 4.处理sources0 (非port)事件
        Boolean sourceHandledThisLoop = __CFRunLoopDoSources0(rl, rlm, stopAfterHandle);
        
        /// 处理sources0返回为YES
        if (sourceHandledThisLoop) {
            /// 执行被加入的block
            __CFRunLoopDoBlocks(rl, rlm);
        }
        
        
        /// 5.如果有 Source1 (基于port) 处于 ready 状态，直接处理这个 Source1 然后跳转去处理消息（9）。
        if (__CFRunLoopServiceMachPort(dispatchPort, &msg, sizeof(msg_buffer), &livePort, 0, &voucherState, NULL)) {
            /// 处理消息
            goto handle_msg;
        }
        
        /// 6.通知 Observers: RunLoop 的线程即将进入休眠(sleep)。
        __CFRunLoopDoObservers(rl, rlm, kCFRunLoopBeforeWaiting);
        // 设置RunLoop为休眠状态。
        __CFRunLoopSetSleeping(rl);
        
        // 内循环，用于接收等待端口的消息
        // 进入此循环后，线程进入休眠，直到收到新消息才跳出该循环，继续执行run loop
        do {
            /// 7.等待被唤醒, 调用 mach_msg 等待接受 mach_port 的消息。线程将进入休眠, 直到被下面某一个事件唤醒。
                /// 7.1 一个基于 port 的 Source1 的事件。
                /// 7.2 一个 Timer 到时间了
                /// 7.3 RunLoop 自身的超时时间到了
                /// 7.4 被其他什么调用者手动唤醒

            // mach 事务 - 指令
            __CFRunLoopServiceMachPort(waitSet, &msg, sizeof(msg_buffer), &livePort, poll ? 0 : TIMEOUT_INFINITY, &voucherState, &voucherCopy);

        } while(1)
          
        
        // 取消runloop的休眠状态，也就是唤醒。
        __CFRunLoopUnsetSleeping(rl);
        
        /// 8.通知 Observers: RunLoop 的线程刚刚被唤醒了。
        __CFRunLoopDoObservers(rl, rlm, kCFRunLoopAfterWaiting);
        
        /// 9.处理唤醒时收到的消息，之后跳转 步骤2
    handle_msg:
            //9.1 如果一个 Timer 到时间了，触发这个Timer的回调。
        if (被Timer唤醒) {
            //处理Timers
            __CFRunLoopDoTimers(rl, rlm, mach_absolute_time())；
        } else if (被GCD唤醒) {
            //9.2 如果有dispatch到main_queue的block，执行block
            __CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__(msg);
        } else if (被Source1唤醒) {
            //9.3 如果一个 Source1 (基于port) 发出事件了，处理这个事件。（被source1唤醒）
            __CFRunLoopDoSource1(rl, rlm, rls, msg, msg->msgh_size, &reply)
        }
        
        /// 执行加入到Loop的block
        __CFRunLoopDoBlocks(rl, rlm);
        
        
        if (sourceHandledThisLoop && stopAfterHandle) {
            //进入loop时参数说处理完事件就返回。
            retVal = kCFRunLoopRunHandledSource;
        } else if (timeout_context->termTSR < mach_absolute_time()) {
            //超出传入参数标记的超时时间了
            retVal = kCFRunLoopRunTimedOut;
        } else if (__CFRunLoopIsStopped(rl)) {
            //被外部调用者强制停止了
            __CFRunLoopUnsetStopped(rl);
            retVal = kCFRunLoopRunStopped;
        } else if (rlm->_stopped) {
            //自动停止了
            rlm->_stopped = false;
            retVal = kCFRunLoopRunStopped;
        } else if (__CFRunLoopModeIsEmpty(rl, rlm, previousMode)) {
            //source/timer/observer一个都没有了
            retVal = kCFRunLoopRunFinished;
        }
        
    } while (0 == retVal);
    
    return retVal;
}

根据源码有以下流程图：

runloop循环流程

同时官方文档中也给出了流程总结：

image.png

5.1 runloop 休眠与唤醒

在第7步前后分别调用了__CFRunLoopSetSleeping与__CFRunLoopUnsetSleeping进行休眠与唤醒操作：

image.png

这里是通过Darwin中的Mach来进行内核态和用户态的切换：

image.png

通过mach_msg()函数接收、发送消息，本质上是调用mach_msg_trap()。在用户态调用 mach_msg_trap()时会切换到内核态，内核态中内核实现的mach_msg()函数会完成实际的工作。

比如触摸屏幕摸到硬件(屏幕)将事件先包装成Event告诉source1(port)，source1唤醒RunLoop然后将事件Event分发给source0由source0来处理。

5.2 mode 切换

默认情况下runloop运行后是在kCFRunLoopDefaultMode模式下的，那么runloop是如何切换mode的呢？
既然要切换mode那么肯定要改变CFRunLoopRunSpecific的参数，搜索CFRunLoopRunSpecific后有在CFRunLoopRunInMode中有调用：

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

而CFRunLoopRunInMode并没有找到调用的时机，给CFRunLoopRunInMode下符号断点：

image.png

可以看到是在-[NSRunLoop(NSRunLoop) runMode:beforeDate:]中以及GSEventRunModal中进行切换的。

六、runloop 应用场景

6.1 runloop 与 mode

6.1.1 mode 与 timer

常用的一个场景是在TableView中的定时器在滚动的时候回调是不执行的。因为这个时候runloop的mode从NSDefaultRunLoopMode切换到了UITrackingRunLoopMode。而timer默认情况下是加在NSDefaultRunLoopMode下的。
这个时候就需要将timer同时加到NSDefaultRunLoopMode与UITrackingRunLoopMode下：

[[NSRunLoop currentRunLoop] addTimer:timer forMode:NSRunLoopCommonModes];

加入NSRunLoopCommonModes下就可以了。当然也可以使用GCD的timer实现计时器。

6.1.2 mode 与页面刷新

怎样保证子线程数据回来更新UI的时候不打断用户的滑动操作？
不打断用户操作那么当runloop在NSDefaultRunLoopMode模式的时候页面就不在滑动状态。那么就当主线程RunLoop由UITrackingRunLoopMode切换到NSDefaultRunLoopMode时再去更新UI：

[self performSelectorOnMainThread:@selector(reloadData) withObject:nil waitUntilDone:NO modes:@[NSDefaultRunLoopMode]];

6.2 runloop 与线程

RunLoop与线程时是一一对应的，数据以key(线程)-value(runloop)存储在全局的字典中。默认情况下线程时不开启runloop的（主线程除外）。

6.2.1 线程与 timer

有如下案例（在主线程调用）：

- (void)testRunloop {
    NSLog(@"1");
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
       NSLog(@"2");
       [self performSelector:@selector(performSelectorAction) withObject:nil afterDelay:10];
       NSLog(@"3");
    });
    NSLog(@"4");
}

- (void)performSelectorAction {
   NSLog(@"5");
}

输出：

由于performSelector带了延迟函数（即使延迟时间为0），内部创建了timer，而子线程没有开启runloop添加timer会失败，该方法也就失效了。

当然如果是主队列则没有问题，同步函数则结果依赖调用同步函数的线程。

修改代码如下：

dispatch_async(dispatch_get_global_queue(0, 0), ^{
    NSLog(@"2");
    [[NSRunLoop currentRunLoop] run];
    [self performSelector:@selector(performSelectorAction) withObject:nil afterDelay:10];
    NSLog(@"3");
});

这个时候performSelectorAction仍然不执行，run后runloop中没有事务导致runloop退出了。退出后再添加timer显然不会执行。
那么将run的逻辑在添加timer后就可以了：

dispatch_async(dispatch_get_global_queue(0, 0), ^{
    NSLog(@"2");
    [self performSelector:@selector(performSelectorAction) withObject:nil afterDelay:10];
    [[NSRunLoop currentRunLoop] run];
    NSLog(@"3");
});

这个时候输出：

这个时候即使delay传0也没问题，进一步说明了NStimer是不准的。

那么有个疑问，既然performSelector: withObject : afterDelay:底层是对timer的封装，那么肯定会调用CFRunLoopAddTimer。而runloop不存在的情况下这个函数会直接返回：

image.png
按照理解应该先创建runloop然后添加timer再启动：

[NSRunLoop currentRunLoop];
[self performSelector:@selector(performSelectorAction) withObject:nil afterDelay:0];
[[NSRunLoop currentRunLoop] run];

为什么先添加timer也没问题呢？

image.png

performSelector: withObject : afterDelay:内部会先创建runloop然后添加timer，我们只需要在添加timer后启动runloop。
自己启动RunLoop，一定要在添加item后。

6.2.2 线程常驻

线程保活在实际开发中经常会遇到一些耗时且需要频繁处理的工作，这些工作和UI无关，比如大文件的下载、后台进行数据的上报等。线程常驻的好处是不用频繁的开辟销毁线程节省资源。

6.2.2.1 线程释放验证

创建一个HPThread继承自NSThread，只重写dealloc方便验证线程是否销毁：

- (void)dealloc {
    NSLog(@"%s",__func__);
}

调用如下：

HPThread *thread = [[HPThread alloc] initWithTarget:self selector:@selector(threadAction) object:nil];
[thread start];

- (void)threadAction {
    @autoreleasepool {
        for (int i = 0; i < 100; i++) {
            NSLog(@"子线程任务 􏱉􏲠􏲡􏲬􏲭􏱉􏲠􏲡􏲬􏲭􏱉􏲠􏲡􏲬􏲭%d - %@",i,[NSThread currentThread]);
        }
        NSLog(@"􏱉􏲠􏲡􏲬􏲭􏲖􏲮子线程任务结束- %@",[NSThread currentThread]);
    }
}

这个时候在threadAction中任务执行完毕后HPThread就释放了：

image.png

这个时候如果HPThread改为属性被持有：

@property (nonatomic, strong) HPThread *thread;

HPThread的dealloc就不会执行了，那么这个时候线程释放了么？
创建一个新任务在self. thread中执行：

UITapGestureRecognizer *tap = [[UITapGestureRecognizer alloc] initWithTarget:self action:@selector(tapAction:)];
[self.view addGestureRecognizer:tap];

- (void)tapAction:(UITapGestureRecognizer *)tap {
    //waitUntilDone:YES 􏳋􏳌􏱉􏲠􏲡􏲬􏲭􏲆􏲇􏲷􏳍􏲆􏲇􏰷􏰸执行完 otherChildThreadAction 才执行后续的逻辑，为 NO 就一起直接执行了。
    [self performSelector:@selector(otherChildThreadAction) onThread:self.thread withObject:nil waitUntilDone:NO];
    NSLog(@"单点事件执行完毕");
}

- (void)otherChildThreadAction {
    @autoreleasepool {
        for (int i = 0; i < 10; i++) {
            NSLog(@"otherChildThreadAction 子线程任务 􏱉􏲠􏲡􏲬􏲭􏱉􏲠􏲡􏲬􏲭􏱉􏲠􏲡􏲬􏲭%d - %@",i,[NSThread currentThread]);
        }
        NSLog(@"otherChildThreadAction 􏱉􏲠􏲡􏲬􏲭􏲖􏲮子线程任务结束- %@",[NSThread currentThread]);
    }
}

这个时候otherChildThreadAction并没有执行：

image.png
说明HPThread创建的线程已经释放了。那么说明仅仅持有HPThread并不能保证线程存活。

6.2.2.2 线程保活

image.png

显然pthread_create创建的线程在任务执行完毕后就被释放了，要确保线程执行完后不被释放，那么就要持有它。那么就有两种方式：

1.使用pthread代替HPThread实现线程创建逻辑。
2.使用runloop持有thread。为了让thread不释放，runloop要一直有事务。

使用 pthread 比较麻烦更好的方案是使用runloop的方案。
修改threadAction如下：

- (void)threadAction {
    @autoreleasepool {
        for (int i = 0; i < 100; i++) {
            NSLog(@"子线程任务 􏱉􏲠􏲡􏲬􏲭􏱉􏲠􏲡􏲬􏲭􏱉􏲠􏲡􏲬􏲭%d - %@",i,[NSThread currentThread]);
        }
        // 􏱋􏲯􏲰􏲱􏰷􏲲􏲳􏲠􏲡􏲬􏲭􏲴􏲵􏲶􏲬􏲭􏲆􏲇􏲷􏲸􏲴􏲵􏲠􏲡􏰠􏱖􏲹􏲺􏲻􏲵􏰽􏰾􏲼􏲽􏲠􏲡􏰘􏲾􏲿􏱃􏳀􏲵􏳁􏰙􏰎􏲠􏲡􏳂􏱝􏱋􏳃RunLoop 任务执行完毕后线程就销毁了，线程保活需要加入 runloop
        NSRunLoop *runLoop = [NSRunLoop currentRunLoop];
        //为了 runloop 不退出
        [runLoop addPort:[NSMachPort port] forMode:NSDefaultRunLoopMode];
        [runLoop run];
        //end 不会执行，因为跑do...while 循环了。
        NSLog(@"􏱉􏲠􏲡􏲬􏲭􏲖􏲮子线程任务结束- %@",[NSThread currentThread]);
    }
}

这样就保证了线程不被释放：

image.png

但是这个时候又存在一个问题了。self -> thread -> self造成了循环引用。需要在结束任务的时候退出线程打破循环引用：

@property (nonatomic, assign) BOOL stopped;

UITapGestureRecognizer *doubleTap = [[UITapGestureRecognizer alloc] initWithTarget:self action:@selector(doubleTapAction:)];
doubleTap.numberOfTapsRequired = 2;
[self.view addGestureRecognizer:doubleTap];

- (void)doubleTapAction:(UITapGestureRecognizer *)tap {
    [self performSelector:@selector(exitThread) onThread:self.thread withObject:nil waitUntilDone:NO];
    NSLog(@"双击事件执行完毕");
}

- (void)exitThread {
    self.stopped = YES;
    //􏳢􏳣停止RunLoop，这样只会停止当次的。
    CFRunLoopStop(CFRunLoopGetCurrent());
    [self.thread cancel];
    //􏳒􏳓􏳔􏳕􏳖􏲩􏰚􏰑打破循环引用
    self.thread = nil;
    NSLog(@"%s %@", __func__, [NSThread currentThread]);
}

thread也可以使用- (instancetype)initWithBlock:(void (^)(void))block来创建。虽然没有循环引用了，vc也能释放，但是runloop持有了thread导致线程和runloop不能释放。

这个时候双击然后返回页面仍然不能释放VC，由于runloop是通过run开启的（runUntilDate）也一样，run一旦成功会不停的调用runMode:beforeDate:来运行runloop，而于CFRunLoopStop只停止了一次runloop（runloop仍然持有了线程）。修改threadAction如下：

- (void)threadAction {
    @autoreleasepool {
        for (int i = 0; i < 100; i++) {
            NSLog(@"子线程任务 􏱉􏲠􏲡􏲬􏲭􏱉􏲠􏲡􏲬􏲭􏱉􏲠􏲡􏲬􏲭%d - %@",i,[NSThread currentThread]);
        }
        // 􏱋􏲯􏲰􏲱􏰷􏲲􏲳􏲠􏲡􏲬􏲭􏲴􏲵􏲶􏲬􏲭􏲆􏲇􏲷􏲸􏲴􏲵􏲠􏲡􏰠􏱖􏲹􏲺􏲻􏲵􏰽􏰾􏲼􏲽􏲠􏲡􏰘􏲾􏲿􏱃􏳀􏲵􏳁􏰙􏰎􏲠􏲡􏳂􏱝􏱋􏳃RunLoop 任务执行完毕后线程就销毁了，线程保活需要加入 runloop
        NSRunLoop *runLoop = [NSRunLoop currentRunLoop];
        //为了 runloop 不退出
        [runLoop addPort:[NSMachPort port] forMode:NSDefaultRunLoopMode];
        while (!self.stopped) {
            // 这个方法在没有任务时就睡眠  任务完成了就会退出loop
            [runLoop runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]];
        }
        //不会执行，因为跑do...while 循环了。 self.stopped
        NSLog(@"􏱉􏲠􏲡􏲬􏲭􏲖􏲮子线程任务结束- %@",[NSThread currentThread]);
    }
}

这个时候通过self.stopped变量控制是否继续run就解决问题了。

runMode: beforeDate:只控制执行一次：

image.png

但是当我们将runMode: beforeDate:的mode修改为NSRunLoopCommonModes后：

image.png
给thread添加任务也不执行，并且cup占满。

等价于UITrackingRunLoopMode：

image.png

所以在while循环中不能一直run在UITrackingRunLoopMode模式。

当然也可以使用CFRunLoop相关函数实现：

// 创建上下文
CFRunLoopSourceContext context = {0};
// 创建source
CFRunLoopSourceRef source = CFRunLoopSourceCreate(kCFAllocatorDefault, 0, &context);
// Runloop中添加source
CFRunLoopAddSource(CFRunLoopGetCurrent(), source, kCFRunLoopDefaultMode);
// 销毁source
CFRelease(source);
// 启动
CFRunLoopRunInMode(kCFRunLoopDefaultMode, 1.0e10, false);

那么CFRunLoop尝试使用common modes：

image.png
直接报错CFRunLoopRunSpecific模式只能传递特定模式。这也就是runMode: beforeDate:启动后给thread添加任务也不执行的原因。

CFRunLoopRunInMode与runMode: beforeDate:只能运行在特定的模式下。
CFRunLoopStop只能退出单次的runloop。

总结:

runloop是一个事件循环，分为内核态和用户态。底层是对do...while的封装。与do...while的区别是它有休眠和唤醒逻辑，从而节省cpu资源、提高程序的性能。
NSRunloop是对CFRunloop的封装。
runloop与线程一一对应，开启runloop依赖于线程，线程不一定开启runloop（主线程默认开启，子线程需要手动开启）。底层是存储在可变字典中key为线程，value为runloop。
runloop与mode是一对多的关系。
- kCFRunLoopDefaultMode/NSDefaultRunLoopMode：默认模式。
- UITrackingRunLoopMode：跟踪用户交互事件。
- kCFRunLoopCommonModes/NSRunLoopCommonModes：伪模式，不是一种真正的运行模式，本质上是同步Source/Timer/Observer到多个Mode中。
mode与source、timer、observer也是一对多的关系。
- CFRunLoopSource分为source0与source1。
  - source0：基于非port也就是用户触发的事件，需要手动唤醒RunLoop，将当前线程从内核态切换到用户态。
  - source1：基于port，包含一个 mach_port 和一个回调。可监听系统端口和通过内核和其他线程发送的消息，能主动唤醒RunLoop，接收分发系统事件。具备唤醒线程的能力。
- CFRunLoopTimer基于时间的触发器，在预设的时间点唤醒RunLoop执行回调。基于runloop所以不是实时的（RunLoop只负责分发消息，如果线程当前正在处理繁重的任务，有可能导致Timer本次延时或者少执行一次）。
- CFRunLoopObserver可以监听runloop的状态。

OC内存管理-runloop

一、runloop 简介

1.1 runloop 输入源与处理机制

二、CFRunloop 的使用

2.1 CFRunLoopMode 验证

2.2 CFRunLoopTimerRef

2.3 CFRunLoopObserverRef

2.4 CFRunLoopSourceRef

2.4.1 source0

2.4.2 source1 线程间通信

三、runloop 结构

3.1 runloop 源码定位

3.2 CFRunLoopRun

3.3 runloop 数据结构

3.3.1 线程与runloop的关系

3.3.2 CFRunLoopRef

3.3.3 RunLoop Modes

四、runloop 事务处理

4.1 timer 事务处理

4.1.1 CFRunLoopAddTimer

4.1.2 CFRunLoopRunSpecific

4.1.3 __CFRunLoopRun

4.1.4 __CFRunLoopDoTimer

4.2 source 事务处理

4.2.1 __CFRunLoopDoSources0

4.2.2 __CFRunLoopDoSources1

4.3 observer 事务处理

4.3.1 CFRunLoopAddObserver

4.3.2 __CFRunLoopDoObservers

4.4 回调函数

4.4.1 CFRUNLOOP_IS_CALLING_OUT_TO_A_TIMER_CALLBACK_FUNCTION

4.4.2 CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE0_PERFORM_FUNCTION

4.4.3 CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE1_PERFORM_FUNCTION

4.4.4 CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION

4.4.5 CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE

4.5.6 source1 与 source0

五、runloop 原理

5.1 runloop 休眠与唤醒

5.2 mode 切换

六、runloop 应用场景

6.1 runloop 与 mode

6.1.1 mode 与 timer

6.1.2 mode 与 页面刷新

6.2 runloop 与 线程

6.2.1 线程 与 timer

6.2.2 线程常驻

6.2.2.1 线程释放验证

6.2.2.2 线程保活

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

runloop

6.1.2 mode 与页面刷新

6.2 runloop 与线程

6.2.1 线程与 timer