投稿
  1. 首页
  2. app

小码哥底层原理之RunLoop

object • 2022-5-21 • app • 阅读 28

小码哥底层原理之RunLoop,第1张

✅作者简介：大家好我是瓜子三百克，励志成为全栈工程师的一枚程序猿，也是喜欢在学习和开发中记录笔记的小白博主！
📃个人主页：瓜子三百克的主页
🔥系列专栏：uniapp前端
💖如果觉得博主的文章还不错的话，请点赞👍+收藏⭐️+留言📝支持一下博主哦🤞


文章目录 一、知识点梳理1、基本介绍2、RunLoop与线程关系3、RunLoop本质3.1、代码底层结构3.2、底层结构逻辑关系3.3、RunLoop执行流程3.4、RunLoop执行源码3.5、CFRunLoopObserverRef对象说明3.6、RunLoop休眠的实现原理 4、RunLoop在实际开发中的应用 二、RunLoop应用示例1、RunLoop运行流程监听2、定时器添加3、线程保活 三、问答拓展

一、知识点梳理 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资源。

**🏆结束语🏆 **

最后如果觉得我写的文章对您有帮助的话，欢迎点赞✌，收藏✌，加关注✌哦，谢谢谢谢！！

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/web/996438.html

赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
object object 一级用户组
0 0
上一篇 2022-05-21
下一篇 2022-05-21

发表评论

登录后才能评论

评论列表（0条）

保存