小码哥底层原理之RunLoop-阿里云开发者社区

一、知识点梳理

1、基本介绍

1、概念：顾名思义，RunLoop是一个运行循环，保证App能够持续运行，处理各种事件，节省CPU资源，没事处理的时候就进入休眠。

简单的RunLoop机制如下：

int main(int argc, const char * argv[]) {
    @autoreleasepool {
  //这行代码会默认创建一个runloop，循环做一些事情，使程序能够持续运行下去
  //return UIApplicationMain(argc, argv, nil,NSStringFromClass([AppDelegate class]));
  // 大概类似于下面代码实现：
        int retVal = 0;
        do {
            //睡眠中等待消息
            int message = sleep_and_wait();
            //处理消息
            retVal = process_message(message);
        } while (0 == retVal);
    }
    return 0;
}

2、NSRunLoop与CFRunLoopRef的关系

1、NSRunLoop是iOS的Foundation对象，CFRunLoopRef是c语言的Core Foundation对象，两个都是一样的。

2、NSRunLoop是对CFRunLoopRef的封装。

3、CFRunLoopRef开源链接：

https://opensource.apple.com/tarballs/CF/

3、获取RunLoop对象

1、Foundation：

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

[NSRunLoop mainRunLoop]; // 获得主线程的RunLoop对象

2、Core Foundation：

CFRunLoopGetCurrent(); // 获得当前线程的RunLoop对象

CFRunLoopGetMain(); // 获得主线程的RunLoop对象

2、RunLoop与线程关系

1、每条线程都有唯一的一个与之对应的RunLoop对象。

2、主线程的RunLoop是默认创建好并开启的，子线程的RunLoop默认是没有的，RunLoop会在第一次获取它时创建，然后手动开启。

3、RunLoop是保存在一个全局的字典里，线程作为Key，RunLoop作为Value。

4、RunLoop会在线程结束时销毁。

//获取当前线程的RunLoop，如果当前线程没有，那会新建一个。
[NSRunLoop currentRunLoop];

3、RunLoop本质

3.1、代码底层结构

struct __CFRunLoop {
  pthread_t _pthread;
  CFMutableSetRef _commonModes;
  CFMutableSetRef _commonModeItems;
  CFRunLoopModeRef _currentMode;
  CFMutableSetRef _modes;
}

每一个RunLoop里面对应只有一个CurrentMode，每个Mode是结构都是一样的：

struct __CFRunLoopMode {
  CFString _name;
  CFMutableSetRef _source0;//点击事件，刷新UI界面，performSelector:onThread:等
  CFMutableSetRef _cource1;//系统内部的事件，基于Port的线程通信，系统事件捕捉等
  CFMutableArrayRef _observers;//监听器，UI刷新
  CFMutableArrayRef _timers;//定时器
}

3.2、底层结构逻辑关系

结构关系如下图：

1、一个RunLoop包含若干个Mode，每个Mode又包含若干个Source0/Source1/Timer/Observer。

2、RunLoop启动时只能选择其中一个Mode，作为CurrentMode

如果需要切换Mode，只能退出当前Loop，再重新选择一个Mode进入。

3、优点：不同组的Source0/Source1/Timer/Observer能分隔开来，互不影响。

4、常见的2种Mode：

1、kCFRunLoopDefaultMode：App的默认Mode，通常主线程是在这个Mode下运行

2、UITrackingRunLoopMode：界面跟踪Mode，用于Scrollview追踪触摸滑动，保证界面滑动时不受其他Mode影响。

3、注意：kCFRunLoopCommonModes默认包括kCFRunLoopDefaultMode、UITrackingRunLoopMode。

3.3、RunLoop执行流程

3.4、RunLoop执行源码

//通知Observers：进入RunLoop
    __CFRunLoopDoObservers(rl, currentMode, kCFRunLoopEntry);
    // 具体要做的事情
    result = __CFRunLoopRun(rl, currentMode, seconds, returnAfterSourceHandled, previousMode);
    // 通知Observers：退出RunLoop
     __CFRunLoopDoObservers(rl, currentMode, kCFRunLoopExit);

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
        if (__CFRunLoopDoSources0(rl, rlm, stopAfterHandle)) {
            //处理Blocks
            __CFRunLoopDoBlocks(rl, rlm);
        }
        Boolean poll = sourceHandledThisLoop || (0ULL == timeout_context->termTSR);
        //判断有无Source1
        if (__CFRunLoopServiceMachPort(dispatchPort, &msg, sizeof(msg_buffer), &livePort, 0, &voucherState, NULL)) {
            //如果有Source1
            goto handle_msg;
        }
        didDispatchPortLastTime = false;
        //通知Observers：即将休眠
        __CFRunLoopDoObservers(rl, rlm, kCFRunLoopBeforeWaiting);
        //休眠
        __CFRunLoopSetSleeping(rl);
        do {//等待别的消息来唤醒当前线程，即等待Source1唤醒线程
            __CFRunLoopServiceMachPort(waitSet, &msg, sizeof(msg_buffer), &livePort, poll ? 0 : TIMEOUT_INFINITY, &voucherState, &voucherCopy);
        } while (1);
        __CFRunLoopUnsetSleeping(rl);
        //通知Observers：结束休眠
        __CFRunLoopDoObservers(rl, rlm, kCFRunLoopAfterWaiting);
        handle_msg:;
         else if (被Timer唤醒) {
            __CFRunLoopDoTimers(rl, rlm, mach_absolute_time())
        } else if (被GCD唤醒) {
            // 处理GCD相关的事情
            __CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__(msg);
        } else {
            //被Source1唤醒
            __CFRunLoopDoSource1(rl, rlm, rls, msg, msg->msgh_size, &reply)
        }
        //处理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;
      }
    } while (0 == retVal);
    return retVal;
}

3.5、CFRunLoopObserverRef对象说明

1、mode结构体对象的作用：

1、Source0

触摸事件处理

performSelector:onThread:

2、Source1

基于Port的线程间通信

系统事件捕捉

3、Timers

NSTimer

performSelector:withObject:afterDelay:

4、Observers

用于监听RunLoop的状态

UI刷新（BeforeWaiting）

Autorelease pool（BeforeWaiting）

3.6、RunLoop休眠的实现原理

4、RunLoop在实际开发中的应用

1、控制线程生命周期（线程保活）

2、解决NSTimer在滑动时停止工作的问题

3、监控应用卡顿

4、性能优化

二、RunLoop应用示例

1、RunLoop运行流程监听

方法一：

void observerRunLoopActicities(CFRunLoopObserverRef observer, CFRunLoopActivity activity, void *info) {
    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;
    }
}
- (void)viewDidLoad {
    [super viewDidLoad];
    // 创建Observer
    CFRunLoopObserverRef observer = CFRunLoopObserverCreate(kCFAllocatorDefault, kCFRunLoopAllActivities, YES, 0, observerRunLoopActicities, NULL);
    // 添加Observer到RunLoop中
    CFRunLoopAddObserver(CFRunLoopGetMain(), observer, kCFRunLoopCommonModes);
    // 释放
    CFRelease(observer);
}

方法二：

- (void)test {
    // 创建Observer
    CFRunLoopObserverRef observer = CFRunLoopObserverCreateWithHandler(kCFAllocatorDefault, 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);
}

2、定时器添加

- (void)viewDidLoad {
    [super viewDidLoad];
    static int count = 0;
    NSTimer *timer = [NSTimer timerWithTimeInterval:1.0 repeats:YES block:^(NSTimer * _Nonnull timer) {
        NSLog(@"%d", ++count);
    /**
    * 1、NSDefaultRunLoopMode、UITrackingRunLoopMode才是真正存在的模式
    * 2、NSRunLoopCommonModes并不是一个真的模式，它只是一个标记
    * 3、timer能在_commonModes数组中存放的模式下工作
    */
    [[NSRunLoop currentRunLoop] addTimer:timer forMode:NSRunLoopCommonModes];
}

3、线程保活

1、ZMPermenantThread.h:

#import <Foundation/Foundation.h>
@interface ZMPermenantThread : NSObject
/**
 在当前子线程执行一个任务
 */
- (void)executeTask:(dispatch_block_t)task;
/**
 结束线程
 */
- (void)stop;
@end

2、ZMPermenantThread.m:

2.1、NSRunLoo实现线程保活

#import "ZMPermenantThread.h"
#pragma mark - ZMThread
@interface ZMThread : NSThread
@end
@implementation ZMThread
- (void)dealloc {
    NSLog(@"%s", __func__);
}
@end
#pragma mark -ZMPermenantThread
@interface ZMPermenantThread()
@property (strong, nonatomic) ZMThread *innerThread;
@property (assign, nonatomic, getter=isStopped) BOOL stopped;
@end
@implementation ZMPermenantThread
#pragma mark - public methods
- (instancetype)init {
    if (self = [super init]) {
        self.stopped = NO;
        __weak typeof(self) weakSelf = self;
        self.innerThread = [[ZMThread alloc] initWithBlock:^{
            [[NSRunLoop currentRunLoop] addPort:[[NSPort alloc] init] forMode:NSDefaultRunLoopMode];
            while (weakSelf && !weakSelf.isStopped) {
              /**
              * NSRunLoop的run方法是无法停止的，它专门用于开启一个永不销毁的线程（NSRunLoop）
              * [[NSRunLoop currentRunLoop] run];
              */
                [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]];
            }
        }];
        [self.innerThread start];
    }
    return self;
}
- (void)executeTask:(dispatch_block_t)task {
    if (!self.innerThread || !task) return;
    [self performSelector:@selector(__executeTask:) onThread:self.innerThread withObject:task waitUntilDone:NO];
}
- (void)stop {
    if (!self.innerThread) return;
    [self performSelector:@selector(__stop) onThread:self.innerThread withObject:nil waitUntilDone:YES];
}
- (void)dealloc {
    NSLog(@"%s", __func__);
    [self stop];
}
#pragma mark - private methods
- (void)__stop {
    self.stopped = YES;
    CFRunLoopStop(CFRunLoopGetCurrent());
    self.innerThread = nil;
}
- (void)__executeTask:(dispatch_block_t)task {
    task();
}
@end

2.2、CFRunLoop 实现线程保活

#import "ZMPermenantThread.h"
#pragma mark-
#pragma mark- ZMThread
@interface ZMThread : NSThread
@end
@implementation ZMThread
- (void)dealloc {
    NSLog(@"%s", __func__);
}
@end
#pragma mark-
#pragma mark- ZMPermenantThread
@interface ZMPermenantThread()
@property (strong, nonatomic) ZMThread *innerThread;
@end
@implementation ZMPermenantThread
#pragma mark- public methods
- (instancetype)init {
    if (self = [super init]) {
        self.innerThread = [[ZMThread alloc] initWithBlock:^{
            NSLog(@"begin----");
            // 创建上下文（要初始化一下结构体）
            CFRunLoopSourceContext context = {0};
            // 创建source
            CFRunLoopSourceRef source = CFRunLoopSourceCreate(kCFAllocatorDefault, 0, &context);
            // 往Runloop中添加source
            CFRunLoopAddSource(CFRunLoopGetCurrent(), source, kCFRunLoopDefaultMode);
            // 销毁source
            CFRelease(source);
            /** 启动
             * @param mode:运行循环模式
             * @param seconds:结束时间，设置最大（1.0e10）
             * @param returnAfterSourceHandled:设置为true，代表执行完source后就会退出当前loop
             */
            CFRunLoopRunInMode(kCFRunLoopDefaultMode, 1.0e10, false);
            NSLog(@"end----");
        }];
        [self.innerThread start];
    }
    return self;
}
- (void)executeTask:(dispatch_block_t)task {
    if (!self.innerThread || !task) return;
    [self performSelector:@selector(__executeTask:) onThread:self.innerThread withObject:task waitUntilDone:NO];
}
- (void)stop {
    if (!self.innerThread) return;
    [self performSelector:@selector(__stop) onThread:self.innerThread withObject:nil waitUntilDone:YES];
}
- (void)dealloc {
    NSLog(@"%s", __func__);
    [self stop];
}
#pragma mark- private methods
- (void)__stop {
    CFRunLoopStop(CFRunLoopGetCurrent());
    self.innerThread = nil;
}
- (void)__executeTask:(dispatch_block_t)task {
    task();
}
@end

ViewController.m实现：

#import "ViewController.h"
#import "ZMPermenantThread.h"
@interface ViewController ()
@property (nonatomic,strong) UIButton *btn;
@property (strong, nonatomic) ZMPermenantThread *thread;
@end
@implementation ViewController
- (void)viewDidLoad {
    [super viewDidLoad];
    [self btn];
    self.thread = [[ZMPermenantThread alloc] init];
}
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
    [self.thread executeTask:^{
        NSLog(@"执行任务 - %@", [NSThread currentThread]);
    }];
}
- (IBAction)stop {
    [self.thread stop];
}
- (void)dealloc {
    NSLog(@"%s", __func__);
}
#pragma mark- lazy
-(UIButton *)btn{
    if (!_btn) {
        _btn = [UIButton new];
        _btn.frame = CGRectMake(100, 100, 100, 100);
        [_btn setTitle:@"结束" forState:UIControlStateNormal];
        [_btn addTarget:self action:@selector(stop) forControlEvents:UIControlEventTouchUpInside];
        [self.view addSubview:_btn];
    }
    return _btn;
}
@end

三、问答拓展

1、讲讲 RunLoop，项目中有用到吗？

看知识点梳理，第4大点。

2、runloop内部实现逻辑？

看知识点梳理，第3.3（流程图）、3.4（代码实现逻辑）大点。

3、runloop和线程的关系？

1、每条线程都有唯一的一个与之对应的RunLoop对象。

2、主线程的RunLoop是默认创建好并开启的，子线程的RunLoop默认是没有的，RunLoop会在第一次获取它时创建，然后手动开启。

3、RunLoop是保存在一个全局的字典里，线程作为Key，RunLoop作为Value。

4、RunLoop会在线程结束时销毁。

4、timer 与 runloop 的关系？

timer运行在runloop中，相当于runloop在控制timer什么时候执行。

5、程序中添加每3秒响应一次的NSTimer，当拖动tableview时timer可能无法响应要怎么解决？

1、原因分析：已知timer默认添加在RunLoop的NSDefaultRunLoopMode的运行模式下，UIScrollview拖动时RunLoop的运行模式会切换到UITrackingRunLoopMode模式，所以timer事件不会被执行。

2、处理方式：timer添加时，将RunLoop的运行模式，设置为NSRunLoopCommonModes（注意：这不是一个真的模式，它只是一个标记，表示可以在NSDefaultRunLoopMode、UITrackingRunLoopMode都能正常执行）

6、runloop 是怎么响应用户操作的，具体流程是什么样的？

1、由source1捕捉用户的操作事件

2、由source0处理用户的操作事件

具体流程：首先由Source1捕捉到用户事件，即用户点击屏幕的时候，这个事件会交给Source1处理，Source1会把这个事件包装成事件队列Event Queue，然后由Source0处理。

7、说说RunLoop的几种状态

8、Runloop的mode作用是什么？

隔离。将不同模式的timer、observer等事件隔离开来。这样可以保证只运行一种模式下的timer、observer的事件，使之在一种模式的条件下运行会比较流畅。

9、实现线程阻塞的方式

while(1)循环

RunLoop休眠

10、RunLoop如何做到休眠？

通过调用mach_msg给内核发送消息，达到真正休眠的目的，不干事情，不占用CPU资源。

小码哥底层原理之RunLoop

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

小码哥底层原理之RunLoop

热门文章

最新文章

相关课程

相关电子书