iOS底层原理之runloop

其他 2018-12-17 09:40:53 阅读次数: 0
版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/Bolted_snail/article/details/82852472

文章目录

RunLoop简介

  • 从字面意思讲跑圈，运行循环。RunLoop就是一个对象，这个对象管理了其需要处理的事件和消息，并提供了一个入口函数来执行上面 Event Loop 的逻辑。线程执行了这个函数后，就会一直处于这个函数内部 “接受消息->等待->处理” 的循环中，直到这个循环结束，函数返回。
    RunLoop
  • 应用范畴
    定时器（Timer）、PerformSelector;
    GCD Async Main Queue;
    事件响应、手势识别、界面刷新;
    网络请求;
    AutoreleasePool。
  • 没有RunLoop时模拟如下：
    没有RunLoop
  • 有RunLoop时模拟如下：（ 程序并不会马上退出，而是保持运行状态）
    有RunLoop时
    有RunLoop时
  • RunLoop的基本作用
    保持程序的持续运行；处理App中的各种事件（比如触摸事件、定时器事件等）；节省CPU资源，提高程序性能：该做事时做事，该休息时休息。

RunLoop对象

  • iOS中有2套API来访问和使用RunLoop,Foundation：NSRunLoop,Core Foundation：CFRunLoopRef,NSRunLoop和CFRunLoopRef都代表着RunLoop对象,NSRunLoop是基于CFRunLoopRef的一层OC包装,CFRunLoopRef是开源的,地址为:https://opensource.apple.com/tarballs/CF/
    NSRunLoop官方文档
  • 获取RunLoop对象
Foundation
[NSRunLoop currentRunLoop]; // 获得当前线程的RunLoop对象
[NSRunLoop mainRunLoop]; // 获得主线程的RunLoop对象

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

RunLoop与线程

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

RunLoop相关的类

  • Core Foundation中关于RunLoop的5个类:
    CFRunLoopRef RunLoop的对象
    CFRunLoopModeRef RunLoop的运行模式
    CFRunLoopSourceRef 输入源/事件源
    CFRunLoopTimerRef Timer事件
    CFRunLoopObserverRef 监听者，监听RunLoop的状态改变
  • RunLoop主要结构如下
    RunLoop主要结构
  1. CFRunLoopModeRef
    CFRunLoopModeRef
    RunLoop内部结构
    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 影响。
  2. CFRunLoopObserverRef
    用来RunLoop监听活动（Run Loop Observer Activities），(<CoreFoundation/CFRunLoop.h>)有以下几种状态，
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
};

添加Observer监听RunLoop的所有状态

//创建监听者
    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);

RunLoop的运行逻辑

RunLoop官网运行逻辑图如下：
RunLoop的运行逻辑
Source0
触摸事件处理
performSelector:onThread:
Source1
基于Port的线程间通信
系统事件捕捉
Timers
NSTimer
performSelector:withObject:afterDelay:
Observers
用于监听RunLoop的状态
UI刷新（BeforeWaiting）
Autorelease pool（BeforeWaiting）

  • 具体执行逻辑流程

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的运行逻辑

RunLoop休眠的实现原理

RunLoop休眠的实现原理
RunLoop休眠其实是从用户态切换到内核态进入休眠状态，然当有事件处理的时候又从内核态切换到用户态去处理事件，这样能够大大的降低性能消耗。

RunLoop在实际开中的应用

  • 控制线程生命周期（线程保活）
    有时候我们需要在一个子线程中做一些事情，并且不想在做完事情后就立马销毁子线程，这时候就需要在子线程里开启一个runLoop来保证这个现在一直存在，在适当的时候销毁。这样做的好处就是避免了多次创建线程造成的性能损耗。
#import "ViewController.h"
#import "HJThread.h"
@interface ViewController ()
@property (strong, nonatomic) HJThread *thread;
@property (assign, nonatomic, getter=isStoped) BOOL stopped;
@end
@implementation ViewController
- (void)viewDidLoad {
    [super viewDidLoad];
    
    __weak typeof(self) weakSelf = self;
    //标记是否停止
    self.stopped = NO;
    //创建线程
    self.thread = [[HJThread alloc] initWithBlock:^{
        NSLog(@"%@----begin----", [NSThread currentThread]);
        
        // 往RunLoop里面添加Source\Timer\Observer
        [[NSRunLoop currentRunLoop] addPort:[[NSPort alloc] init] forMode:NSDefaultRunLoopMode];
        //如果控制器还存在并且没有执行停止(这样的做的目的是放控制器已经销毁造成的怀内存访问)开启运行循环
        while (weakSelf && !weakSelf.isStoped) {
            [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]];
        }
        //只要循环一直存在就不会来到下面，
        NSLog(@"%@----end----", [NSThread currentThread]);
    }];
    //开启x线程执行任务
    [self.thread start];
}

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
{  //防止换内存访问
    if (!self.thread) return;
    [self performSelector:@selector(test) onThread:self.thread withObject:nil waitUntilDone:NO];
}

// 子线程需要执行的任务
- (void)test
{
    NSLog(@"%s %@", __func__, [NSThread currentThread]);
}

- (IBAction)stop {
    if (!self.thread) return;
    
    // 在子线程调用stop（waitUntilDone设置为YES，代表子线程的代码执行完毕后，这个方法才会往下走），这里设置为YES防止在控制器退出时，在子线程中self已经置nil，而循环一直在开启这,造成内存泄漏
    //vc->thread->runloop->vc
    [self performSelector:@selector(stopThread) onThread:self.thread withObject:nil waitUntilDone:YES];
}

// 用于停止子线程的RunLoop
- (void)stopThread
{
    // 设置标记为YES
    self.stopped = YES;
    
    // 停止RunLoop
    CFRunLoopStop(CFRunLoopGetCurrent());
    NSLog(@"%s %@", __func__, [NSThread currentThread]);
    
    // 清空线程
    self.thread = nil;
}

- (void)dealloc
{
    NSLog(@"%s", __func__);
    
    [self stop];
}
@end
  • 线程保活封装
    这样用起来还是比较麻烦的，尤其会忽略内存泄漏和坏内存访问问题，最好是封装为一个工具类，为了避免影响系统的一些方法，并且要用到成员变量，这里就封装一个继承NSObject的子类,而不适用分类和继承。

HJPermenantThread.h文件，公共接口

#import <Foundation/Foundation.h>
typedef void (^HJPermenantThreadTask)(void);
@interface HJPermenantThread : NSObject
/**
 开启线程
 */
//- (void)run;

/**
 在当前子线程执行一个任务
 */
- (void)executeTask:(HJPermenantThreadTask)task;

/**
 结束线程
 */
- (void)stop;
@end

HJPermenantThread.m文件，封装功能的实现

#import "MJPermenantThread.h"

/** MJThread **/
@interface HJThread : NSThread
@end
@implementation HJThread
- (void)dealloc
{
    NSLog(@"%s", __func__);
}
@end

/** MJPermenantThread **/
@interface HJPermenantThread()
@property (strong, nonatomic) HJThread *innerThread;
@property (assign, nonatomic, getter=isStopped) BOOL stopped;
@end

@implementation HJPermenantThread
#pragma mark - public methods
- (instancetype)init
{
    if (self = [super init]) {
        self.stopped = NO;
        
        __weak typeof(self) weakSelf = self;
        
        self.innerThread = [[HJThread alloc] initWithBlock:^{
            [[NSRunLoop currentRunLoop] addPort:[[NSPort alloc] init] forMode:NSDefaultRunLoopMode];
            //每次调用__executeTask时都会来这里判断循环是否还在
            while (weakSelf && !weakSelf.isStopped) {
                NSLog(@"循环： %s",__func__);
                [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]];
            }
        }];
        
        [self.innerThread start];
    }
    return self;
}
//执行任务
- (void)executeTask:(HJPermenantThreadTask)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;
}

//执行block任务
- (void)__executeTask:(HJPermenantThreadTask)task
{
    task();
}
@end

调用

@interface ViewController ()
@property (strong, nonatomic) MJPermenantThread *thread;
@end

@implementation ViewController
- (void)viewDidLoad {
    [super viewDidLoad];
    
    self.thread = [[MJPermenantThread 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__);
}
  • 用CFRunLoop封装
#import "HJPermenantThread.h"

/** HJThread **/
@interface HJThread : NSThread
@end
@implementation HJThread
- (void)dealloc
{
    NSLog(@"%s", __func__);
}
@end

/** HJPermenantThread **/
@interface HJPermenantThread()
@property (strong, nonatomic) HJThread *innerThread;
@end

@implementation HJPermenantThread
#pragma mark - public methods
- (instancetype)init
{
    if (self = [super init]) {
        self.innerThread = [[HJThread alloc] initWithBlock:^{
            NSLog(@"begin----");
            
            // 创建上下文（要初始化一下结构体）
            CFRunLoopSourceContext context = {0};
            
            // 创建source
            CFRunLoopSourceRef source = CFRunLoopSourceCreate(kCFAllocatorDefault, 0, &context);
            
            // 往Runloop中添加source
            CFRunLoopAddSource(CFRunLoopGetCurrent(), source, kCFRunLoopDefaultMode);
            
            // 销毁source
            CFRelease(source);
            
            // 启动
            CFRunLoopRunInMode(kCFRunLoopDefaultMode, 1.0e10, false);
            NSLog(@"end----");
        }];
        
        [self.innerThread start];
    }
    return self;
}
- (void)executeTask:(HJPermenantThreadTask)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:(MJPermenantThreadTask)task
{
    task();
}
@end
  • 解决NSTimer在滑动时停止工作的问题
    用时候需要在UITableview中添加定时器倒计时功能，例如京东天猫的抢单功能，但是当tableView滚动时，定时器就会停止工作，原因是定时器是工作在NSDefaultRunLoopMode模式下,当滚动tableView时，RunLoop会切换到UITrackingRunLoopMode模式下，NSTimer就会暂停等待，等滚动完再切换到默认模式下定时器就又开始工作了；我们只需要要将定时器添加到NSRunLoopCommonModes模式下就可以了。
    NSTimer *timer = [NSTimer timerWithTimeInterval:1.0 repeats:YES block:^(NSTimer * _Nonnull timer) {
        NSLog(@"%d", ++count);
    }];
//    [[NSRunLoop currentRunLoop] addTimer:timer forMode:NSDefaultRunLoopMode];//默认模式
//    [[NSRunLoop currentRunLoop] addTimer:timer forMode:UITrackingRunLoopMode];//用户界面追踪模式
    // NSDefaultRunLoopMode、UITrackingRunLoopMode才是真正存在的模式
    // NSRunLoopCommonModes并不是一个真的模式，它只是一个标记
    // timer能在_commonModes数组中存放的模式下工作
    [[NSRunLoop currentRunLoop] addTimer:timer forMode:NSRunLoopCommonModes];

注意：NSRunLoopCommonModes并不是一个真的模式，它只是一个标记。

  • 监控应用卡顿
  • 性能优化

面试题

  1. 讲讲 RunLoop，项目中有用到吗？
    RunLoop就是一个对象，运行循环，这个对象管理了其需要处理的事件和消息，并提供了一个入口函数来执行上面 Event Loop 的逻辑。线程执行了这个函数后，就会一直处于这个函数内部 “接受消息->等待->处理” 的循环中，直到这个循环结束，函数返回。数据请求，定时器等会用到。

  2. runloop内部实现逻辑？

  3. runloop和线程的关系？
    一一对应的关系，主线程默认开启runloop，子线程在第一次获取时开启线程（默认不开启）。

  4. timer 与 runloop 的关系？
    timer默认是runloop默认模式下的一种事件。

  5. 程序中添加每3秒响应一次的NSTimer，当拖动tableview时timer可能无法响应要怎么解决？程序中添加每3秒响应一次的NSTimer，当拖动tableview时timer可能无法响应要怎么解决？
    设置RunLoop的模式为NSRunLoopCommonModes。

  6. runloop 是怎么响应用户操作的， 具体流程是什么样的？
    如果是用户界面没有操作，runloop会在默认模式下的内核态休眠，当要相应响应用户操作，会切退出默认模式，进入用户界面追踪模式，并且切换到用户态去响应用户的操作，当响应完成后，就退出用户界面追踪模式，进入默认模式，并且切换到内核态进行休眠。

  7. 说说runLoop的几种状态说说runLoop的几种状态

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. runloop的mode作用是什么？
    切换不同的模式来处理不同的事件。

猜你喜欢

转载自blog.csdn.net/Bolted_snail/article/details/82852472
今日推荐
“开源信徒”周鸿祎开源360智脑大模型
华为ensp中vrrp虚拟路由器冗余协议 原理及配置命令
基于Python爬虫广东广州水酒店宾馆数据可视化系统设计与实现(Django框架) 研究背景与意义、国内外研究现状
知识融合：知识图谱构建的关键技术
文心一言收费还是免费：全面解析其价格策略与服务价值
百万用户通话新风潮：仅需50秒，无界AI让彩铃变身短视频
【STM32项目】基于STM32多传感器融合的新型智能导盲杖设计（完整工程资料源码）
文生视频大模型Sora的复现经验
腾讯云函数计算技术：云原生架构下的Serverless与微服务新篇章
干货分享｜JumpServer 三种常见的文件传输方式效果对比
【榜单公布】2023年度征文活动已结束
周排行
Java中关于时间的操作及格式化
《HTML5与CSS3基础教程》第五章学习笔记 图像
nginx下安装PHP发生问题的逐步解决
HDU-1048，The Hardest Problem Ever（字符串处理）
新一代多媒体技术与应用的部分课后题
Shader 绘制特殊图形
Oracle数据库三种备份方案
CodeForces - 983B XOR-pyramid(两次区间DP/记忆化DFS)
Python3基础语法——变量与运算符
（转载）KMP算法详解 （原创）详解KMP算法
每日归档
更多
2024-04-16(70)
2024-04-15(42)
2024-04-14(0)
2024-04-13(119)
2024-04-12(38)
2024-04-11(14)
2024-04-10(68)
2024-04-09(5)
2024-04-08(60)
2024-04-07(4)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022