OC底层原理探索-NSRunLoop

作者: 十年开发初学者 | 来源:发表于2021-10-19 17:55 被阅读0次

RunLoop应用

image.png

这张图是苹果官网中图，接下来通过示例理解这种图


- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view.
    // 循环引用
    
    [NSTimer scheduledTimerWithTimeInterval:1 repeats:YES block:^(NSTimer * _Nonnull timer) {
        // __CFRUNLOOP_IS_CALLING_OUT_TO_A_TIMER_CALLBACK_FUNCTION__
        NSLog(@"1111");
    }];
//
    
    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(gotNotification:) name:@"MyNotification" object:nil];
       
       [self performSelector:@selector(fire) withObject:nil afterDelay:1.0];
////
       dispatch_async(dispatch_get_main_queue(), ^{
           //__CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__
           NSLog(@"hello word");
       });
//
       void (^block)(void) = ^{
           //__CFRUNLOOP_IS_CALLING_OUT_TO_A_BLOCK__
           NSLog(@"123");
       };

       block();
}

- (void)fire {
    //__CFRUNLOOP_IS_CALLING_OUT_TO_A_TIMER_CALLBACK_FUNCTION__
    NSLog(@"performSeletor");
}

- (void)gotNotification:(NSNotification *)noti {
    
     NSLog(@"gotNotification = %@",noti);
}

#pragma mark - 触摸事件
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
    NSLog(@"来了,老弟!!!");
    // __CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE0_PERFORM_FUNCTION__
    [[NSNotificationCenter defaultCenter] postNotificationName:@"MyNotification" object:@"ssl"];
}

@end

首先测试下NStimer，断点bt下

image.png

这里timer收到runloop影响
这里有个__CFRUNLOOP_IS_CALLING_OUT_TO_A_TIMER_CALLBACK_FUNCTION__

测试下block

image.png

这里block收到runloop影响
这里有个__CFRUNLOOP_IS_CALLING_OUT_TO_A_BLOCK__

这里就不一一进行测试了，给出其余几种情况

timer：__CFRUNLOOP_IS_CALLING_OUT_TO_A_TIMER_CALLBACK_FUNCTION__
GCD主队列：__CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__
source0:__CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE0_PERFORM_FUNCTION__
source1:__CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE1_PERFORM_FUNCTION__
observer ：__CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__
block:__CFRUNLOOP_IS_CALLING_OUT_TO_A_BLOCK__

RunLoop作用

保持程序的持续运行
处理App的各种时间（触摸、定时器等）
节省CPU资源、提供程序的性能：做事的时候做事、休息的时候休息

RunLoop与线程关系

在CFRunLoop源码中找到CFRunLoopGetMain和CFRunLoopGetCurrent方法

image.png

进入_CFRunLoopGet0方法


CF_EXPORT CFRunLoopRef _CFRunLoopGet0(pthread_t t) {
    if (pthread_equal(t, kNilPthreadT)) {
        t = pthread_main_thread_np();
    }
    __CFLock(&loopsLock);
    if (!__CFRunLoops) {
        __CFUnlock(&loopsLock);

    // 创建一个可变字典
    CFMutableDictionaryRef dict = CFDictionaryCreateMutable(kCFAllocatorSystemDefault, 0, NULL, &kCFTypeDictionaryValueCallBacks);
        
    // 创建主线程runloop
    CFRunLoopRef mainLoop = __CFRunLoopCreate(pthread_main_thread_np());
        
    // 进行绑定 dict[@"pthread_main_thread_np"] = mainLoop
    CFDictionarySetValue(dict, pthreadPointer(pthread_main_thread_np()), mainLoop);
        
        
    if (!OSAtomicCompareAndSwapPtrBarrier(NULL, dict, (void * volatile *)&__CFRunLoops)) {
        CFRelease(dict);
    }
    CFRelease(mainLoop);
        __CFLock(&loopsLock);
    }
    // 根据当前线程获取loop
    CFRunLoopRef loop = (CFRunLoopRef)CFDictionaryGetValue(__CFRunLoops, pthreadPointer(t));
    __CFUnlock(&loopsLock);
    // 如果不是主线程，进行类似操作将线程和创建的CFRunLoopRef进行绑定
    if (!loop) {
    CFRunLoopRef newLoop = __CFRunLoopCreate(t);
        __CFLock(&loopsLock);
    loop = (CFRunLoopRef)CFDictionaryGetValue(__CFRunLoops, pthreadPointer(t));
    if (!loop) {
        CFDictionarySetValue(__CFRunLoops, pthreadPointer(t), newLoop);
        loop = newLoop;
    }
        // don't release run loops inside the loopsLock, because CFRunLoopDeallocate may end up taking it
        __CFUnlock(&loopsLock);
    CFRelease(newLoop);
    }
    if (pthread_equal(t, pthread_self())) {
        _CFSetTSD(__CFTSDKeyRunLoop, (void *)loop, NULL);
        if (0 == _CFGetTSD(__CFTSDKeyRunLoopCntr)) {
            _CFSetTSD(__CFTSDKeyRunLoopCntr, (void *)(PTHREAD_DESTRUCTOR_ITERATIONS-1), (void (*)(void *))__CFFinalizeRunLoop);
        }
    }
    return loop;
}

如果__CFRunLoops不存在，创建CFMutableDistionaryRef,并默认初始化主线程的RunLoop并将RunLoop放入到字典中,线程为key，runloop为value
在通过线程获取RunLoop时，以key-value方式从字典中获取对应的RunLoop；
如果RunLoop为空,则创建一个newLoop，以线程为key，RunLoop为value，存储到__CFRunLoops中

【线程总结】线程的RunLoop会默认被创建，而子线程的RunLoop是懒加载的，需要时才会创建，RunLoop和线程是一对一的关系，存储在一个字典中。

子线程runLoop分析

    dispatch_queue_t queue = dispatch_queue_create("", NULL);
    dispatch_async(queue, ^{
        NSLog(@"running....");

          [NSTimer scheduledTimerWithTimeInterval:1.0 repeats:YES block:^(NSTimer * _Nonnull timer) {
              NSLog(@"helloc timer...%@", [NSThread currentThread]);
          }];
        
    });

image.png
由上图可知，这里只打印了定时器前的打印，定时任务并没有执行，这是因为NSTimer需要依赖于RunLoop，主线程的RunLoop默认开启，而子线程的RunLoop是懒加载，需要手动开启。

image.png

RunLoop数据结构

创建RunLoop是使用的__CFRunLoopCreate函数，查看函数实现：

image.png
CFRunLoopRef是结构体指针，查看__CFRunLoop结构体：

struct __CFRunLoop {
    CFRuntimeBase _base;
    pthread_mutex_t _lock;            /* locked for accessing mode list */
    __CFPort _wakeUpPort;            // used for CFRunLoopWakeUp
    Boolean _unused;
    volatile _per_run_data *_perRunData;              // reset for runs of the run loop
    pthread_t _pthread;
    uint32_t _winthread;
    CFMutableSetRef _commonModes;
    CFMutableSetRef _commonModeItems;
    CFRunLoopModeRef _currentMode;
    CFMutableSetRef _modes;
    struct _block_item *_blocks_head;
    struct _block_item *_blocks_tail;
    CFAbsoluteTime _runTime;
    CFAbsoluteTime _sleepTime;
    CFTypeRef _counterpart;
};

由这个结构体，可以得知一个runLoop对应_commonModes,这个_commonModes是个集合类型，所以一个runLoop对应多个mode

mode定义

struct __CFRunLoopMode {
    CFStringRef _name;
    CFMutableSetRef _sources0;
    CFMutableSetRef _sources1;
    CFMutableArrayRef _observers;
    CFMutableArrayRef _timers;
    ...
};

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

__CFRunLoopMode源码定义中包括了4个set集合_sources0、_sources1、_observers、_timers，这四个集合也就是我们常说的事件（事务）。所以我们可以得出结论：CFRunLoopMode和sourses、timer、observer也是一对多的关系。

这里的timer、observer比较好理解，什么是_sources0、_sources1呢？

image.png

mode类型
-kCFRunLoopDefaultMode 默认的运行模式，通常主线程是在这个Mode下运行
-UITrackingRunLoopMode 界面跟踪Mode，用于ScrollView等视图，追踪触摸滑动，保证界面的滑动不受其他Mode的影响
-UIInitializationRunLoopMode 在刚启动App时进入的第一个Mode，启动完成后就不在使用
-GSEventReceiveRunLoopMode 接受系统时间的内部Mode，通常用不到
-kCFRunLoopCommonModes 是一个伪模式，可以在标记为CommonModes的模式下运行，RunLoop会自动将_commonModeItems里的source、observe、timer同步到具有标记的Mode里。

image.png

runLoop原理

在源码中查找CFRunLoopRunSpecific的方法实现，见下图：

image.png
由上图可知：这个函数是对runLoop的生命周期的处理,进入__CFRunLoopRun

/**
 *  运行 run loop
 *
 *  @param rl              运行的RunLoop对象
 *  @param rlm             运行的mode
 *  @param seconds         run loop超时时间
 *  @param stopAfterHandle true:run loop处理完事件就退出  false:一直运行直到超时或者被手动终止
 *  @param previousMode    上一次运行的mode
 *
 *  @return 返回4种状态
 */
static int32_t __CFRunLoopRun(CFRunLoopRef rl, CFRunLoopModeRef rlm, CFTimeInterval seconds, Boolean stopAfterHandle, CFRunLoopModeRef previousMode) {
    
    int32_t retVal = 0;
    
    do {  // itmes do
        
        /// 2. 通知 Observers: RunLoop 即将触发 Timer 回调。
        __CFRunLoopDoObservers(rl, rlm, kCFRunLoopBeforeTimers);
        
        /// 3. 通知 Observers: RunLoop 即将触发 Source0 (非port) 回调。
        __CFRunLoopDoObservers(rl, rlm, kCFRunLoopBeforeSources)
        
        /// 执行被加入的block
        __CFRunLoopDoBlocks(rl, rlm);
        
        /// 4. RunLoop 触发 Source0 (非port) 回调。
        Boolean sourceHandledThisLoop = __CFRunLoopDoSources0(rl, rlm, stopAfterHandle);
        
        /// 处理sources0返回为YES
        if (sourceHandledThisLoop) {
            /// 执行被加入的block
            __CFRunLoopDoBlocks(rl, rlm);
        }
        
        /// 5. 如果有 Source1 (基于port) 处于 ready 状态，直接处理这个 Source1 然后跳转去处理消息。
        if (__CFRunLoopServiceMachPort(dispatchPort, &msg, sizeof(msg_buffer), &livePort, 0, &voucherState, NULL)) {
            /// 如果接收到了消息的话，前往第9步开始处理消息
            goto handle_msg;
        }
        
        /// 6.通知 Observers: RunLoop 的线程即将进入休眠(sleep)。
        __CFRunLoopDoObservers(rl, rlm, kCFRunLoopBeforeWaiting);
        __CFRunLoopSetSleeping(rl);
        
        /// 7. 接收waitSet端口的消息
        __CFRunLoopServiceMachPort(waitSet, &msg, sizeof(msg_buffer), &livePort, poll ? 0 : TIMEOUT_INFINITY, &voucherState, &voucherCopy);
        
        /// 7. 等待接受 mach_port 的消息。线程将进入休眠, 直到被下面某一个事件唤醒。
        /// • 一个基于 port 的Source 的事件。
        /// • 一个 Timer 到时间了
        /// • RunLoop 自身的超时时间到了
        /// • 被其他什么调用者手动唤醒
        
        // 取消runloop的休眠状态
        __CFRunLoopUnsetSleeping(rl);
        
        /// 8. 通知 Observers: RunLoop 的线程刚刚被唤醒了。
        __CFRunLoopDoObservers(rl, rlm, kCFRunLoopAfterWaiting);
        
    handle_msg:
        if (被Timer唤醒) {
            /// 9.1 如果一个 Timer 到时间了，触发这个Timer的回调。
            __CFRunLoopDoTimers(rl, rlm, mach_absolute_time())；
        } else if (被GCD唤醒) {
            /// 9.2 如果有dispatch到main_queue的block，执行block
            __CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__(msg);
        } else if (被Source1唤醒) {
            /// 9.3 如果一个 Source1 (基于port) 发出事件了，处理这个事件
            __CFRunLoopDoSource1(rl, rlm, rls, msg, msg->msgh_size, &reply)
        }
        
        /// 执行加入到Loop的block
        __CFRunLoopDoBlocks(rl, rlm);
        
        if (sourceHandledThisLoop && stopAfterHandle) {
            /// 进入loop时参数说处理完事件就返回。
            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)) {
            /// source/timer/observer一个都没有了
            retVal = kCFRunLoopRunFinished;
        }
        /// 如果没超时，mode里没空，loop也没被停止，那继续loop。
    } while (0 == retVal);
    
    return retVal;
}

下图就是上图的处理逻辑

image.png

【总结】
RunLoop是通过系统内部维护的循环进行事件、消息管理的一个对象。RunLoop实际上就是一个do...while循环，有任务时开始，无任务时休眠。本质是通过mach_msg()函数接收、发送消息。

CFRunLoopModeRef 这样设计有什么好处？Runloop为什么会有多个 Mode？

-Mode 做到了屏蔽的效果，当RunLoop运行在 Mode1 下面的时候，是处理不了 Mode2 的事件的；
比如NSDefaultRunLoopMode默认模式和UITrackingRunLoopMode滚动模式，滚动屏幕的时候就会切换到滚动模式，就不用去处理默认模式下的事件了，保证了 UITableView等的滚动顺畅。

RunLoop与线程的关系：

每个线程都有一个与之对应的RunLoop，所以RunLoop与线程是一一对应的，其绑定关系通过一个全局的DIctionary存储，线程为key，runloop为value。
线程中的RunLoop主要是用来管理线程的，当线程的RunLoop开启后，会在执行完任务后进行休眠状态，当有事件触发唤醒时，又开始工作，即有活时干活，没活就休息
主线程的RunLoop是默认开启的，在程序启动之后，会一直运行，不会退出
其他线程的RunLoop默认是不开启的，如果需要，则手动开启

RunLoop中涉及到5个重要的类：

CFRunLoop - RunLoop对象
CFRunLoopMode - 五种运行模式
CFRunLoopSource - 输入源/事件源，包括Source0和Source1
CFRunLoopTimer - 定时源，也就是NSTimer
CFRunLoopObserve - 观察者，用来监听RunLoop

CFRunLoopSource - 事件源

Source1:基于mach_port和回调函数指针，也就是端口通讯，处理来自系统内核或其他进程的事件，比如点击手机屏幕
Source0:非基于Port的处理事件，也就是应用层事件（内部事件、APP负责管理的事件，UIEvent），包含一个回调函数指针，需要手动标记为待处理或者手动唤醒RunLoop，如performSelector、block等
例如：一个APP在前台静止，用户点击APP界面，屏幕表面的时事件会先包装成Event告诉source1（基于mach_port），source1唤醒RunLoop将事件Event分发给source0，由source0来处理。

CFRunLooTimer - 定时源
就是NSTimer，在预设的时间点唤醒RunLoop执行回调。因为它是基于RunLoop的，因此它不是实时的（Timer是不准确的，因为RunLoop只负责分发源消息。如果线程当前正在处理繁重的任务，就有可能导致Timer本次延时，或者少执行一次）。

CFRunLoopObserver - 观察者
用来监听时间点事件CFRunLoopActivity。

KCFRunLoopEntery RunLoop准备启动
kCFRunLoopBeforeTimers RunLoop将要处理一些Timer相关的事件
kCFRunLoopBeforeSources RunLoop将要处理一些Source事件
kCFRunLoopBeforeWaiting RunLoop将要进行休眠状态，即将由用户状态切换内核态
kCFRunLoopAfterWaiting RunLoop被唤醒，即从内核态切换到用户态
kCFRunLoopExit RunLoop退出
kCfRunLoopAllActivitires 监听所有状态

为什么main函数能够保持一直存在且不退出？
在main函数内容会调用UIApplication函数，而在UIAPPlicationMain内部会启动主线程的RunLoop，可以做到有消息处理，能够迅速从内核态到用户态的切换，立刻唤醒处理，而没有消息处理时，通过用户态到内核态的切换进入等待状态，避免资源的占用。因此main函数能够一直存在并且不退出。

NSRunLoop 和 CFRunLoopRef 区别

NSRunLoop是基于CFRunLoopRef面向对象的API，是不安全的
CFRunLoopRef是基于C语言，是线程安全的

Runloop的mode作用是什么？
mode主要是用于指定RunLoop中事件优先级的

OC底层原理探索-NSRunLoop

RunLoop应用

RunLoop作用

RunLoop与线程关系

【线程总结】线程的RunLoop会默认被创建，而子线程的RunLoop是懒加载的，需要时才会创建，RunLoop和线程是一对一的关系，存储在一个字典中。

RunLoop数据结构

runLoop原理

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读