定义

  • 顾名思义
    • 运行循环
    • 在程序运行过程中循环做一些事情
  • 应用范畴
    • 定时器（Timer），PerformSelector
    • GCD Async Main Queue
    • 事件响应，手势识别，界面刷新
    • 网络请求
    • AutoreleasePool

如果没有RunLoop，执行完13行代码之后，会退出程序

1
2
3
4
5
6
int main(int argc, const char* argv[]) {
    @autoreleasepool {
        NSLog(@"Hello World！")
    }
    return 0;
}

如果有了RunLoop

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
int main(int argc, char * argv[]) {
    @autoreleasepool {
        return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));
    }
}

//伪代码
int main(int argc, char * argv[]) {
    @autoreleasepool {
        int retVal = 0;
        do {
            // 睡眠中等待消息
            int message = sleep_and_wait();
            // 处理消息
            retVal = process_message(message);
        } while (0 == retVal);
        return 0;
    }
}

程序并不会马上退出，而是保持运行状态
RunLoop的基本作用

  • 保持程序的持续运行
  • 处理App中的各种事件（比如触摸事件、定时器事件）
  • 节省CPU资源，提高程序性能：该做事时做事，该休息时休息

RunLoop对象

  • iOS中有2套API来访问和使用RunLoop
    • Foundation: NSRunLoop
    • Core Foundation: CFRunLoopRef
  • NSRunLoop和CFRunLoop都代表着RunLoop对象

获取RunnLoop对象

Foundation

1
2
[NSRunLoop currentRunLoop]; // 获得当前线程的RunLoop对象
[NSRunLoop mainRunLoop]; // 获得主线程的RunLoop对象

Core Foundation

1
2
CFRunLoopGetCurrent(); // 获得当前线程的RunLoop对象
CFRunLoopGetMain(); // 获得主线程的RunLoop对象

RunLoop与线程

  • 每条线程都有唯一的一个与之对应的RunLoop对象
  • RunLoop保存在一个全局的Dictionary里，线程作为key，RunLoop作为value
  • 线程刚创建时并没有RunLoop对象，RunLoop会在第一次获取它时创建
  • RunLoop会在线程结束时销毁
  • 主线程的RunLoop已经自动获取（创建），子线程默认没有开启RunLoop

RunLoop相关的类

  • Core Foundation中关于RunLoop的5个类
    • CFRunLoopRef
    • CFRunLoopModeRef
    • CFRunLoopSourceRef
    • CFRunLoopTimerRef
    • CFRunLoopObserverRef

CFRunLoopRef

1
2
3
4
5
6
7
8
typedef struct __CFRunLoop * CFRunLoopRef:
struct __CFRunLoop {
    pthread_t _pthread;
    CFMutableSetRef _commonModes;
    CFMutableSetRef _commonModesItems;
    CFMutableModeRef _currentMode;
    CFMutableSetRef _modes;
}

CFRunLoopModeRef

1
2
3
4
5
6
7
8
typedef struct __CFRunLoopMode * CFRunLoopModeRef:
struct __CFRunLoopMode {
    CFStringRef _name;
    CFMutableSetRef _sources0;
    CFMutableSetRef _sources1;
    CFMutableArrayRef _observers;
    CFMutableArrayRef _timers;
}

CFRunLoopModeRef

  • CFRunLoopModeRef代表RunLoop的运行模式
  • 一个RunLoop包含若干个Mode，每个Mode又包含若干个Source0/Source1/Timer/Observer
  • RunLoop启动时只能选择其中一个Mode，作为currentMode
  • 如果需要切换Mode，只能退出当前Loop，再重新选择一个Mode进入
    • 不同组的Source0/Source1/Timer/Observer能分隔开来，互不影响
  • 如果Mode里没有任何Source0/Source1/Timer/Observer，RunLoop会立马退出

常见的2种Mode

  • kCFRunLoopDefaultMode（NSDefaultRunLoopMode）：App的默认Mode，通常主线程是在这个Mode下运行
  • UITrackingRunLoopMode：界面跟踪 Mode，用于 ScrollView 追踪触摸滑动，保证界面滑动时不受其他 Mode 影响

CFRunLoopObserverRef

observer的各个状态：

1
2
3
4
5
6
7
8
9
10
/* Run Loop Observer Activities */
typedef CF_OPTIONS(CFOptionFlags, CFRunLoopActivity) {
    kCFRunLoopEntry = (1UL << 0),           //即将进入Loop
    kCFRunLoopBeforeTimers = (1UL << 1),    //即将处理Timer
    kCFRunLoopBeforeSources = (1UL << 2),   //即将处理Source
    kCFRunLoopBeforeWaiting = (1UL << 5),   //即将进入休眠
    kCFRunLoopAfterWaiting = (1UL << 6),    //刚从休眠中唤醒
    kCFRunLoopExit = (1UL << 7),            //即将退出Loop
    kCFRunLoopAllActivities = 0x0FFFFFFFU
};

基本使用： 

1
2
3
4
5
6
// 创建Observer
CFRunLoopObserverRef observer = CFRunLoopObserverCreate(kCFAllocatorDefault, kCFRunLoopAllActivities, YES, 0, observeRunLoopActicities, NULL);
// 添加Observer到RunLoop中
CFRunLoopAddObserver(CFRunLoopGetMain(), observer, kCFRunLoopCommonModes);
// 释放
CFRelease(observer);

添加Observer监听RunLoop的所有状态

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// 创建Observer
CFRunLoopObserverRef ob = CFRunLoopObserverCreateWithHandler(kCFAllocatorNull, kCFRunLoopAllActivities, YES, 0, ^(CFRunLoopObserverRef observer, CFRunLoopActivity activity) {
    switch (activity) {
        case kCFRunLoopEntry:
            NSLog(@"kCFRunLoopEntry");
            break;
        case kCFRunLoopBeforeTimers:
            NSLog(@"kCFRunLoopBeforeTimers");
            break;
        case kCFRunLoopBeforeSources:
            NSLog(@"kCFRunLoopBeforeSources");
            break;
        case kCFRunLoopBeforeWaiting:
            NSLog(@"kCFRunLoopBeforeWaiting");
            break;
        case kCFRunLoopAfterWaiting:
            NSLog(@"kCFRunLoopAfterWaiting");
            break;
        case kCFRunLoopExit:
            NSLog(@"kCFRunLoopExit");
            break;
        default:
            break;
    }
});
// 添加Observer到RunLoop中
CFRunLoopAddObserver(CFRunLoopGetMain(), observer, kCFRunLoopCommonModes);
// 释放
CFRelease(observer);

RunLoop的运行逻辑

  • Source0
    • 触摸事件处理
    • performSelector:onThread:
  • Source1
    • 基于Port的线程间通信
    • 系统事件捕捉
  • Timers
    • NSTimer
    • performSelector:withObject:afterDelay:
  • Observers
    • 用于监听RunLoop的状态
    • UI刷新（BeforeWaiting）
    • Autorelease pool（BeforeWaiting）

底层逻辑

源码分析

CFRunLoop.h文件
CFRunLoopRunSpecific（精简源码）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
SInt32 CFRunLoopRunSpecific(CFRunLoopRef rl, CFStringRef modeName, CFTimeInterval seconds, Boolean returnAfterSourceHandled) {     /* DOES CALLOUT */
    __CFRunLoopLock(rl);
    
    // 通知Observers：进入Loop
    __CFRunLoopDoObservers(rl, currentMode, kCFRunLoopEntry);
    
    // 具体要做的事情
    result = __CFRunLoopRun(rl, currentMode, seconds, returnAfterSourceHandled, previousMode);
    
    //通知Observers：退出Loop
    __CFRunLoopDoObservers(rl, currentMode, kCFRunLoopExit);
    
    __CFRunLoopUnlock(rl);
    return result;
}

__CFRunLoopRun（精简源码）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
static int32_t __CFRunLoopRun(CFRunLoopRef rl, CFRunLoopModeRef rlm, CFTimeInterval seconds, Boolean stopAfterHandle, CFRunLoopModeRef previousMode) {
    int32_t retVal = 0;
    do {
        // 通知Observers: 即将处理Timers
        __CFRunLoopDoObservers(rl, rlm, kCFRunLoopBeforeTimers);
        // 通知Observers: 即将处理Sources
        __CFRunLoopDoObservers(rl, rlm, kCFRunLoopBeforeSources);
        
        //处理Blocks
        __CFRunLoopDoBlocks(rl, rlm);

        //处理Source0
        Boolean sourceHandledThisLoop = __CFRunLoopDoSources0(rl, rlm, stopAfterHandle);
        if (sourceHandledThisLoop) {
            //处理Blocks
            __CFRunLoopDoBlocks(rl, rlm);
    }

    //判断有无Source1
    if (__CFRunLoopServiceMachPort(dispatchPort, &msg, sizeof(msg_buffer), &livePort, 0, &voucherState, NULL)) {
    
        //如果有Source1,就跳转handle_msg
        goto handle_msg;
    }
        
    // 通知Observers: 即将休眠
    __CFRunLoopDoObservers(rl, rlm, kCFRunLoopBeforeWaiting);
    // 通知Observers: 开始休眠
    __CFRunLoopSetSleeping(rl);
        
    // 等待别的消息来唤醒当前线程
    __CFRunLoopServiceMachPort(waitSet, &msg, sizeof(msg_buffer), &livePort, poll ? 0 : TIMEOUT_INFINITY, &voucherState, &voucherCopy);
    
    __CFRunLoopUnsetSleeping(rl);
    // 通知Observers: 结束休眠
    __CFRunLoopDoObservers(rl, rlm, kCFRunLoopAfterWaiting);

handle_msg:;
    if (被timers唤醒) {
        // 处理Timers
        __CFRunLoopDoTimers(rl, rlm, mach_absolute_time()))
    } else if (livePort == dispatchPort) {//被gcd唤醒
        // 处理GCD
        __CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__(msg);
    } else {//被Source1唤醒
        // 处理Source1
        __CFRunLoopDoSource1(rl, rlm, rls, msg, msg->msgh_size, &reply) || sourceHandledThisLoop;
    }
    //处理Blocks
    __CFRunLoopDoBlocks(rl, rlm);
        
    // 设置返回值
    if (sourceHandledThisLoop && stopAfterHandle) {
        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)) {
        retVal = kCFRunLoopRunFinished;
    }
        voucher_mach_msg_revert(voucherState);
        os_release(voucherCopy);

    } while (0 == retVal);

    return retVal;
}

流程描述：

  • 01、通知Observers：进入Loop
  • 02、通知Observers：即将处理Timers
  • 03、通知Observers：即将处理Sources
  • 04、处理Blocks
  • 05、处理Source0（可能会再次处理Blocks）
  • 06、如果存在Source1，就跳转到第8步
  • 07、通知Observers：开始休眠（等待消息唤醒）
  • 08、通知Observers：结束休眠（被某个消息唤醒）
    • 01 处理Timer
    • 02 处理GCD Async To Main Queue
    • 03 处理Source1
  • 09、处理Blocks
  • 10、根据前面的执行结果，决定如何操作
    • 01 回到第02步
    • 02 退出Loop
  • 11、通知Observers：退出Loop

RunLoop在实际开中的应用

  • 控制线程生命周期（线程保活）
  • 解决NSTimer在滑动时停止工作的问题
  • 监控应用卡顿
  • 性能优化

参考