iOS RunLoop

2021-03-24 本文已影响0人 Nothing_xy

什么是RunLoop？

可以理解为字面意思：Run表示运行，Loop表示循环。结合在一起就是运行的循环的意思。哈哈，我更愿意翻译为『跑圈』。直观理解就像是不停的跑圈
RunLoop实际上是一个对象，这个对象在循环中用来处理程序运行过程中出现的各种事件（比如说触摸事件、UI刷新事件、定时器事件、Selector事件），从而保持程序的持续运行；而且在没有事件处理的时候，会进入睡眠模式，从而节省CPU资源，提高程序性能
RunLoop保存在一个全局的字典里，线程作为key，RunLoop作为value

RunLoop内部结构

_modes：存放所有的模式
_pthread：存放的线程
_currentMode：当前的模式

c3d9bf03.jpg

RunLoopMode内部结构

_soutce0, _soutce1:存放在CFRunLoopSourceRef
_observers:存放在CFRunLoopObserverRef
_timers:存放在CFRunLoopTimerRef

3df6dff2.jpg

RunLoop和线程

RunLoop和线程是息息相关的，我们知道线程的作用是用来执行特定的一个或多个任务，但是在默认情况下，线程执行完之后就会退出，就不能再执行任务了。这时我们就需要采用一种方式来让线程能够处理任务，并不退出。所以，我们就有了RunLoop
- 一条线程对应一个RunLoop对象，每条线程都有唯一一个与之对应的RunLoop对象。
- 我们只能在当前线程中操作当前线程的RunLoop，而不能去操作其他线程的RunLoop。
- RunLoop对象在第一次获取RunLoop时创建，销毁则是在线程结束的时候。
- 主线程的RunLoop对象系统自动帮助我们创建好了(原理如下)，而子线程的RunLoop对象需要我们主动创建。
- 子线程的runLoop里面至少要有一个source或者是timer，observer是不行的。

默认情况下主线程的RunLoop原理

我们在启动一个iOS程序的时候，系统会调用创建项目时自动生成的main.m的文件。main.m文件如下所示：

int main(int argc, char * argv[]) {
   @autoreleasepool {
       return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));
   }
}

其中UIApplicationMain函数内部帮我们开启了主线程的RunLoop，UIApplicationMain内部拥有一个无线循环的代码。上边的代码中开启RunLoop的过程可以简单的理解为如下代码：
```
 int main(int argc, char * argv[]) {        
     BOOL running = YES;
     do {
         // 执行各种任务，处理各种事件
         // ......
     } while (running);

     return 0;
 }
```
从上边可看出，程序一直在do-while循环中执行，所以UIApplicationMain函数一直没有返回，我们在运行程序之后程序不会马上退出，会保持持续运行状态。

下图是苹果官方给出的RunLoop模型图。
1877784-6ab632fc118e31f3.jpg

从上图中可以看出，RunLoop就是线程中的一个循环，RunLoop在循环中会不断检测，通过Input sources（输入源）和Timer sources（定时源）两种来源等待接受事件；然后对接受到的事件通知线程进行处理，并在没有事件的时候进行休息

RunLoop相关类

下面我们来了解一下Core Foundation框架下关于RunLoop的5个类，只有弄懂这几个类的含义，我们才能深入了解RunLoop运行机制
- CFRunLoopRef：代表RunLoop的对象
- CFRunLoopModeRef：RunLoop的运行模式
- CFRunLoopSourceRef：就是RunLoop模型图中提到的输入源/事件源
  - source0:
    - 触摸事件，
    - performSelector：onThread
  - source1：
    - 基于Port的线程间的通信
    - 系统事件的捕捉
- CFRunLoopTimerRef：就是RunLoop模型图中提到的定时源
  - NSTimer
  - performSelector：withObject:afterDelay
- CFRunLoopObserverRef：观察者，能够监听RunLoop的状态改变
  - 用于监听RunLoop的状态
  - UI刷新（BeforeWaiting）
  - AutoreleasePool
    
    1877784-2177aa2828b1ad34.png

CFRunLoopRef

CFRunLoopRef就是Core Foundation框架下RunLoop对象类。我们可通过以下方式来获取RunLoop对象：
- Core Foundation
  - CFRunLoopGetCurrent(); // 获得当前线程的RunLoop对象
  - CFRunLoopGetMain(); // 获得主线程的RunLoop对象
  当然，在Foundation框架下获取RunLoop对象类的方法如下：
- Foundation
  - [NSRunLoop currentRunLoop]; // 获得当前线程的RunLoop对象
  - [NSRunLoop mainRunLoop]; // 获得主线程的RunLoop对象

CFRunLoopModeRef

CFRunLoopModeRef代表着RunLoop的运行模式
一个RunLoop有若干个Mode，每个模式又包含若干个Source0，Source1，Timers，Observer
RunLoop启动时只能选择其中一个Mode，作为currentMode
如果需要切换运行模式，只能退出Loop，再重新选择一个运行模式进入。
这样做主要是为了分隔开不同组的Source0，Source1，Timers，Observer，让其互不影响。
如果Mode里面没有Source0，Source1，Timers，Observer，RunLoop会马上退出

常见的几种模式

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

CFRunLoopObserverRef

创建Observer

typedef CF_OPTIONS(CFOptionFlags, CFRunLoopActivity) {
   kCFRunLoopEntry = (1UL << 0),               // 即将进入Loop：1
   kCFRunLoopBeforeTimers = (1UL << 1),        // 即将处理Timer：2    
   kCFRunLoopBeforeSources = (1UL << 2),       // 即将处理Source：4
   kCFRunLoopBeforeWaiting = (1UL << 5),       // 即将进入休眠：32
   kCFRunLoopAfterWaiting = (1UL << 6),        // 即将从休眠中唤醒：64
   kCFRunLoopExit = (1UL << 7),                // 即将从Loop中退出：128
   kCFRunLoopAllActivities = 0x0FFFFFFFU       // 监听全部状态改变  
};


 //创建一个监听对象
 //    第一个参数：分配存储空间
 //    第二个参数：要监听的状态
 //    第三个参数： 是否要持续监听
 //    第四个参数：优先级
 //    第五个参数：回调
  CFRunLoopObserverRef obser =  CFRunLoopObserverCreateWithHandler(CFAllocatorGetDefault(), kCFRunLoopAllActivities, YES, 0, ^(CFRunLoopObserverRef observer, CFRunLoopActivity activity) {
 //        状态判断
         switch (activity) {
             case kCFRunLoopEntry:

                 break;
             case kCFRunLoopBeforeTimers:

                 break;
             case kCFRunLoopBeforeSources:

                 break;
             case kCFRunLoopBeforeWaiting:

                 break;
             case kCFRunLoopAfterWaiting:

                 break;
             case kCFRunLoopExit:

                 break;
             case kCFRunLoopAllActivities:

                 break;
             default:
                 break;
         }
     });

 //    第一个参数：要监听哪个Loop
 //    第二个参数：监听者
 //    第三个参数： 要监听runloop在哪种运行模式下的状态
 CFRunLoopAddObserver(CFRunLoopGetCurrent(), obser, kCFRunLoopDefaultMode);

CFRunLoopTimerRef

创建定时器

NSTimer *time =[NSTimer timerWithTimeInterval:2.0 target:self selector:@selector(test) userInfo:nil repeats:YES];
//设置runloop,添加到默认模式下
[[NSRunLoop currentRunLoop] addTimer:time forMode:NSDefaultRunLoopMode];
//设置runloop,添加到拖拽模式下
 [[NSRunLoop currentRunLoop] addTimer:time forMode:UITrackingRunLoopMode];
//NSRunLoopCommonModes标记,在两种模式下都会运行
[[NSRunLoop currentRunLoop] addTimer:time forMode:NSRunLoopCommonModes];

RunLoop运行逻辑

2dbc55cb.jpg

具体的顺序如下：
- 1.通知观察者RunLoop已经启动
- 2.通知观察者即将要开始的定时器
- 3.通知观察者任何即将启动的非基于端口的源
- 4.启动任何准备好的非基于端口的源
- 5.如果基于端口的源准备好并处于等待状态，立即启动；并进入步骤9
- 6.通知观察者线程进入休眠状态
- 7.将线程置于休眠知道任一下面的事件发生：
  - 某一事件到达基于端口的源
  - 定时器启动
  - RunLoop设置的时间已经超时
  - RunLoop被显示唤醒
- 8.通知观察者线程将被唤醒
- 9.处理未处理的事件
  - 如果用户定义的定时器启动，处理定时器事件并重启RunLoop。进入步骤2
  - 如果输入源启动，传递相应的消息
  - 如果RunLoop被显示唤醒而且时间还没超时，重启RunLoop。进入步骤2
- 10.通知观察者RunLoop结束

RunLoop运用场景详情

4.1 NSTimer的使用

NSTimer的使用方法在讲解CFRunLoopTimerRef类的时候详细讲解过，具体参考上边 2.3 CFRunLoopTimerRef。

4.2 ImageView推迟显示

有时候，我们会遇到这种情况：
当界面中含有UITableView，而且每个UITableViewCell里边都有图片。这时候当我们滚动UITableView的时候，如果有一堆的图片需要显示，那么可能会出现卡顿的现象。

怎么解决这个问题呢？

这时候，我们应该推迟图片的显示，也就是ImageView推迟显示图片。有两种方法：

* 1. 监听UIScrollView的滚动
  因为UITableView继承自UIScrollView，所以我们可以通过监听UIScrollView的滚动，实现UIScrollView相关delegate即可。

* 2. 利用PerformSelector设置当前线程的RunLoop的运行模式

 利用performSelector方法为UIImageView调用setImage:方法，并利用inModes将其设置为RunLoop下NSDefaultRunLoopMode运行模式。代码如下：

4.3 后台常驻线程（很常用）

- (void)viewDidLoad {
   [super viewDidLoad];

   // 创建线程，并调用run1方法执行任务
   self.thread = [[NSThread alloc] initWithTarget:self selector:@selector(run1) object:nil];
   // 开启线程
   [self.thread start];    
}

- (void) run1
{
   // 这里写任务
   NSLog(@"----run1-----");

   // 添加下边两句代码，就可以开启RunLoop，之后self.thread就变成了常驻线程，可随时添加任务，并交于RunLoop处理
   [[NSRunLoop currentRunLoop] addPort:[NSPort port] forMode:NSDefaultRunLoopMode];
   [[NSRunLoop currentRunLoop] run];

   // 测试是否开启了RunLoop，如果开启RunLoop，则来不了这里，因为RunLoop开启了循环。
   NSLog(@"未开启RunLoop");
}

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
{   
   // 利用performSelector，在self.thread的线程中调用run2方法执行任务
   [self performSelector:@selector(run2) onThread:self.thread withObject:nil waitUntilDone:NO];
}

- (void) run2
{
   NSLog(@"----run2------");
}

4.3 封装常驻线程

//MJPermenantThread.h
typedef void (^MJPermenantThreadTask)(void);

@interface MJPermenantThread : NSObject

/**
开启线程
*/
//- (void)run;

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

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

@end

//MJPermenantThread.m

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

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

@implementation MJPermenantThread
#pragma mark - public methods
- (instancetype)init
{
  if (self = [super init]) {
      self.stopped = NO;

      __weak typeof(self) weakSelf = self;

      self.innerThread = [[MJThread alloc] initWithBlock:^{
          [[NSRunLoop currentRunLoop] addPort:[[NSPort alloc] init] forMode:NSDefaultRunLoopMode];

          while (weakSelf && !weakSelf.isStopped) {
              [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]];
          }
      }];

      [self.innerThread start];
  }
  return self;
}

//- (void)run
//{
//    if (!self.innerThread) return;
//
//    [self.innerThread start];
//}

- (void)executeTask:(MJPermenantThreadTask)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:(MJPermenantThreadTask)task
{
  task();
}

@end

//调用
(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__);
}

RunLoop休眠实现原理

b2b20b35.jpg