iOS开发 oc中重要知识点

RunLoop研究

2016-12-04  本文已影响133人  jiodg45

目录:

启动原理

从app启动开始,调用堆栈的信息可以看出,程序启动时,默认开启了一个runLoop,存在于Thread1。

Snip20161204_5.png

上图中,系统首先调用 start函数，程序开始执行main函数,

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

runLoop的概念

* 通过上面的为代码将runLoop简写成了一个死循环,在每次的循环周期类,它不停的接受事件,处理事件,等待唤醒和睡眠.
在没有事情做的时候,它会进入睡眠状态,释放CPU资源,在程序接受到事件后,它会从消息队列(messageQueue)中一条一条的将事件取出,然后进行执行,这里只是初步介绍一下,实际在每次runLoop过程中它还进行了 界面刷新,GCD分派事件的调度,系统内核MarchPort事件处理，以及系统强制插入的程序中的其它紧急事件处理。后面会进行一一介绍。
* 总的来说,mainRunLoop主要干了三件事情：
   + 让程序一直活着,保持持续的监听(网络或者用户的输入)
   + 解耦,通过从消息队列的轮询,使得接受到的事件能有序的进行处理(防止一个触摸事件之后,后面的事件都没办法处理)。
   + 节省CPU资源,这个效果就非常明显了,睡眠就是最好的实现方式。

#### RunLoop 与线程的关系
+ 下面先来看一段源码:
```objective-c
          /// 全局的Dictionary，key 是 pthread_t， value 是 CFRunLoopRef
          static CFMutableDictionaryRef loopsDic;
          /// 访问 loopsDic 时的锁
          static CFSpinLock_t loopsLock;
  
          /// 获取一个 pthread 对应的 RunLoop。
          CFRunLoopRef _CFRunLoopGet(pthread_t thread) {
          OSSpinLockLock(&loopsLock);
            if (!loopsDic) {
            // 第一次进入时，初始化全局Dic，并先为主线程创建一个 RunLoop。
              loopsDic = CFDictionaryCreateMutable();
              CFRunLoopRef mainLoop = _CFRunLoopCreate();
              CFDictionarySetValue(loopsDic, pthread_main_thread_np(), mainLoop);
              }
     
                /// 直接从 Dictionary 里获取。
             CFRunLoopRef loop = CFDictionaryGetValue(loopsDic, thread));
     
              if (!loop) {
                /// 取不到时，创建一个
                loop = _CFRunLoopCreate();
                CFDictionarySetValue(loopsDic, thread, loop);
                /// 注册一个回调，当线程销毁时，顺便也销毁其对应的 RunLoop。
                _CFSetTSD(..., thread, loop, __CFFinalizeRunLoop);
                }
     
                  OSSpinLockUnLock(&loopsLock);
            return loop;
            }
  
            CFRunLoopRef CFRunLoopGetMain() {
            return _CFRunLoopGet(pthread_main_thread_np());
            }
  
          CFRunLoopRef CFRunLoopGetCurrent() {
           return _CFRunLoopGet(pthread_self());
           }

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
          };

RunLoop 的 Mode

        struct __CFRunLoopMode {
         CFStringRef _name;            // Mode Name, 例如 @"kCFRunLoopDefaultMode"
         CFMutableSetRef _sources0;    // Set
         CFMutableSetRef _sources1;    // Set
         CFMutableArrayRef _observers; // Array
         CFMutableArrayRef _timers;    // Array
         ...
        };
  
        struct __CFRunLoop {
        CFMutableSetRef _commonModes;     // Set
        CFMutableSetRef _commonModeItems; // Set
        CFRunLoopModeRef _currentMode;    // Current Runloop Mode
        CFMutableSetRef _modes;           // Set
   
        };

RunLoop 的内部逻辑

          /// 此处为程序启动时指定的RunLoop用DefaultMode启动
         void CFRunLoopRun(void) {
        CFRunLoopRunSpecific(CFRunLoopGetCurrent(), kCFRunLoopDefaultMode, 1.0e10, false);
         }
        /// 用指定的Mode启动，允许设置RunLoop超时时间
        int CFRunLoopRunInMode(CFStringRef modeName, CFTimeInterval seconds, Boolean stopAfterHandle) {
         return CFRunLoopRunSpecific(CFRunLoopGetCurrent(), modeName, seconds, returnAfterSourceHandled);
         } 
           /// RunLoop的实现
           int CFRunLoopRunSpecific(runloop, modeName, seconds, stopAfterHandle) {
           /// 首先根据modeName找到对应mode
           CFRunLoopModeRef currentMode = __CFRunLoopFindMode(runloop, modeName, false);
           /// 如果mode里没有source/timer/observer, 直接返回
           if (__CFRunLoopModeIsEmpty(currentMode)) return;
     
           /// 1. 通知 Observers: RunLoop 即将进入 loop。
           __CFRunLoopDoObservers(runloop, currentMode, kCFRunLoopEntry);
     
             /// 内部函数，进入loop
           __CFRunLoopRun(runloop, currentMode, seconds, returnAfterSourceHandled) {
         
           Boolean sourceHandledThisLoop = NO;
           int retVal = 0;
            do {
  
               /// 2. 通知 Observers: RunLoop 即将触发 Timer 回调。
              __CFRunLoopDoObservers(runloop, currentMode, kCFRunLoopBeforeTimers);
            /// 3. 通知 Observers: RunLoop 即将触发 Source0 (非port) 回调。
            __CFRunLoopDoObservers(runloop, currentMode, kCFRunLoopBeforeSources);
            /// 执行被加入的block
            __CFRunLoopDoBlocks(runloop, currentMode);
             
            /// 4. RunLoop 触发 Source0 (非port) 回调。
            sourceHandledThisLoop = __CFRunLoopDoSources0(runloop, currentMode, stopAfterHandle);
            /// 执行被加入的block
            __CFRunLoopDoBlocks(runloop, currentMode);
  
            /// 5. 如果有 Source1 (基于port) 处于 ready 状态，直接处理这个 Source1 然后跳转去处理消息。
            if (__Source0DidDispatchPortLastTime) {
                Boolean hasMsg = __CFRunLoopServiceMachPort(dispatchPort, &msg)
                if (hasMsg) goto handle_msg;
              }
             
            /// 通知 Observers: RunLoop 的线程即将进入休眠(sleep)。
            if (!sourceHandledThisLoop) {
                __CFRunLoopDoObservers(runloop, currentMode, kCFRunLoopBeforeWaiting);
              }
               
            /// 7. 调用 mach_msg 等待接受 mach_port 的消息。线程将进入休眠, 直到被下面某一个事件唤醒。
            /// ? 一个基于 port 的Source 的事件。
            /// ? 一个 Timer 到时间了
            /// ? RunLoop 自身的超时时间到了
            /// ? 被其他什么调用者手动唤醒
             __CFRunLoopServiceMachPort(waitSet, &msg, sizeof(msg_buffer), &livePort) {
                mach_msg(msg, MACH_RCV_MSG, port); // thread wait for receive msg
               }
  
              /// 8. 通知 Observers: RunLoop 的线程刚刚被唤醒了。
            __CFRunLoopDoObservers(runloop, currentMode, kCFRunLoopAfterWaiting);
             
            /// 收到消息，处理消息。
            handle_msg:
  
            /// 9.1 如果一个 Timer 到时间了，触发这个Timer的回调。
            if (msg_is_timer) {
                __CFRunLoopDoTimers(runloop, currentMode, mach_absolute_time())
            } 
  
            /// 9.2 如果有dispatch到main_queue的block，执行block。
            else if (msg_is_dispatch) {
                __CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__(msg);
              } 
  
            /// 9.3 如果一个 Source1 (基于port) 发出事件了，处理这个事件
             else {
                CFRunLoopSourceRef source1 = __CFRunLoopModeFindSourceForMachPort(runloop, currentMode, livePort);
                sourceHandledThisLoop = __CFRunLoopDoSource1(runloop, currentMode, source1, msg);
                if (sourceHandledThisLoop) {
                    mach_msg(reply, MACH_SEND_MSG, reply);
                }
              }
             
            /// 执行加入到Loop的block
            __CFRunLoopDoBlocks(runloop, currentMode);
            if (sourceHandledThisLoop && stopAfterHandle) {
                /// 进入loop时参数说处理完事件就返回。
                retVal = kCFRunLoopRunHandledSource;
            } else if (timeout) {
                /// 超出传入参数标记的超时时间了
                retVal = kCFRunLoopRunTimedOut;
            } else if (__CFRunLoopIsStopped(runloop)) {
                /// 被外部调用者强制停止了
                retVal = kCFRunLoopRunStopped;
            } else if (__CFRunLoopModeIsEmpty(runloop, currentMode)) {
                /// source/timer/observer一个都没有了
                retVal = kCFRunLoopRunFinished;
            }
             
            /// 如果没超时，mode里没空，loop也没被停止，那继续loop。
              } while (retVal == 0);
              }
     
             /// 10. 通知 Observers: RunLoop 即将退出。
            __CFRunLoopDoObservers(rl, currentMode, kCFRunLoopExit);
             }

RunLoop 功能实现

        CFRunLoop {
          current mode = kCFRunLoopDefaultMode
          common modes = {
            UITrackingRunLoopMode
            kCFRunLoopDefaultMode
        }
  
        common mode items = {
  
        // source0 (manual)
        CFRunLoopSource {order =-1, {
            callout = _UIApplicationHandleEventQueue}}
        CFRunLoopSource {order =-1, {
            callout = PurpleEventSignalCallback }}
        CFRunLoopSource {order = 0, {
            callout = FBSSerialQueueRunLoopSourceHandler}}
  
        // source1 (mach port)
        CFRunLoopSource {order = 0,  {port = 17923}}
        CFRunLoopSource {order = 0,  {port = 12039}}
        CFRunLoopSource {order = 0,  {port = 16647}}
        CFRunLoopSource {order =-1, {
            callout = PurpleEventCallback}}
        CFRunLoopSource {order = 0, {port = 2407,
            callout = _ZL20notify_port_callbackP12__CFMachPortPvlS1_}}
        CFRunLoopSource {order = 0, {port = 1c03,
            callout = __IOHIDEventSystemClientAvailabilityCallback}}
        CFRunLoopSource {order = 0, {port = 1b03,
            callout = __IOHIDEventSystemClientQueueCallback}}
        CFRunLoopSource {order = 1, {port = 1903,
            callout = __IOMIGMachPortPortCallback}}
  
        // Ovserver
        CFRunLoopObserver {order = -2147483647, activities = 0x1, // Entry
            callout = _wrapRunLoopWithAutoreleasePoolHandler}
        CFRunLoopObserver {order = 0, activities = 0x20,          // BeforeWaiting
            callout = _UIGestureRecognizerUpdateObserver}
        CFRunLoopObserver {order = 1999000, activities = 0xa0,    // BeforeWaiting | Exit
            callout = _afterCACommitHandler}
        CFRunLoopObserver {order = 2000000, activities = 0xa0,    // BeforeWaiting | Exit
            callout = _ZN2CA11Transaction17observer_callbackEP19__CFRunLoopObservermPv}
        CFRunLoopObserver {order = 2147483647, activities = 0xa0, // BeforeWaiting | Exit
            callout = _wrapRunLoopWithAutoreleasePoolHandler}
  
        // Timer
        CFRunLoopTimer {firing = No, interval = 3.1536e+09, tolerance = 0,
            next fire date = 453098071 (-4421.76019 @ 96223387169499),
            callout = _ZN2CAL14timer_callbackEP16__CFRunLoopTimerPv (QuartzCore.framework)}
    },
  
        modes ＝ {
        CFRunLoopMode  {
            sources0 =  { /* same as 'common mode items' */ },
            sources1 =  { /* same as 'common mode items' */ },
            observers = { /* same as 'common mode items' */ },
            timers =    { /* same as 'common mode items' */ },
        },
  
          CFRunLoopMode  {
            sources0 =  { /* same as 'common mode items' */ },
            sources1 =  { /* same as 'common mode items' */ },
            observers = { /* same as 'common mode items' */ },
            timers =    { /* same as 'common mode items' */ },
        },
  
          CFRunLoopMode  {
            sources0 = {
                CFRunLoopSource {order = 0, {
                    callout = FBSSerialQueueRunLoopSourceHandler}}
            },
            sources1 = (null),
            observers = {
                CFRunLoopObserver >{activities = 0xa0, order = 2000000,
                    callout = _ZN2CA11Transaction17observer_callbackEP19__CFRunLoopObservermPv}
            )},
            timers = (null),
          },
  
            CFRunLoopMode  {
            sources0 = {
                CFRunLoopSource {order = -1, {
                    callout = PurpleEventSignalCallback}}
              },
            sources1 = {
                CFRunLoopSource {order = -1, {
                    callout = PurpleEventCallback}}
            },
              observers = (null),
              timers = (null),
          },
         
          CFRunLoopMode  {
            sources0 = (null),
            sources1 = (null),
            observers = (null),
            timers = (null),
            }
          }
      }

        {
        /// 1. 通知Observers，即将进入RunLoop
          /// 此处有Observer会创建AutoreleasePool: _objc_autoreleasePoolPush();
           __CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__(kCFRunLoopEntry);
    do {
  
        /// 2. 通知 Observers: 即将触发 Timer 回调。
                    __CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__(kCFRunLoopBeforeTimers);
          /// 3. 通知 Observers: 即将触发 Source (非基于port的,Source0) 回调。
                __CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__(kCFRunLoopBeforeSources);
        __CFRUNLOOP_IS_CALLING_OUT_TO_A_BLOCK__(block);
  
        /// 4. 触发 Source0 (非基于port的) 回调。
            __CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE0_PERFORM_FUNCTION__(s  ource0);
          __CFRUNLOOP_IS_CALLING_OUT_TO_A_BLOCK__(block);
  
        /// 6. 通知Observers，即将进入休眠
        /// 此处有Observer释放并新建AutoreleasePool: _objc_autoreleasePoolPop(); _objc_autoreleasePoolPush();
                __CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__(kCFRunLoopBeforeWaiting);
  
        /// 7. sleep to wait msg.
        mach_msg() -> mach_msg_trap();
         
  
        /// 8. 通知Observers，线程被唤醒
        __CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__(kCFRunLoopAfterWaiting);
  
        /// 9. 如果是被Timer唤醒的，回调Timer
        __CFRUNLOOP_IS_CALLING_OUT_TO_A_TIMER_CALLBACK_FUNCTION__(timer);
  
        /// 9. 如果是被dispatch唤醒的，执行所有调用 dispatch_async 等方法放入main queue 的 block
        __CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__(dispatched_block);
  
        /// 9. 如果如果Runloop是被 Source1 (基于port的) 的事件唤醒了，处理这个事件
        __CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE1_PERFORM_FUNCTION__(source1);
  
  
        } while (...);
  
        /// 10. 通知Observers，即将退出RunLoop
          /// 此处有Observer释放AutoreleasePool: _objc_autoreleasePoolPop();
          __CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION_  _(kCFRunLoopExit);
}

AutoreleasePool

事件响应

手势识别

界面更新

当在操作UI,比如改变了frame,更新了UIView/CALayer的层次时,或者手动调用了setNeedsLayout和setNeedsDisplay方法后将这个UIView或者CALayer标记为待处理。并提交到一个全局的容器中去. 由于前面苹果对RunLoop也注册了一个_ZN2CA11Transaction17observer_callbackEP19__CFRunLoopObservermPv观察者,当观察者发现runLoop将要休息或者空闲的时候,就会让runloop去取前面的标记事件去处理。 这也是为甚么如果界面其它source0事件处理耗时较长的时候主界面会的原因,因为一般用户自定义的事件是在runLoop正常运行时就开始执行，而手势和界面动画,布局相关的事件是在 runLoop收集完这一次循环中标记的所有事件后,并且将要休眠的时候才处理,排布的优先级别较高,如果前面的事件耗时较久,超时了,就会导致后面的界面刷新卡顿，或者直接放次本次循环的刷新。

定时器

NSTimer基于CFRunLoopTimerRef封装,当一个NSTimer注册到RunLoop中后,runLoop会为其重复的事件点注册好事件,为了节省资源,通常情况下runLoop并不会在非常精确的事件点执行这个事件,通常会在注册事件的时候指定一个tolerance(误差值)，当标示的时间节点到后,会直接执行,如果执行的事件较长,超过了下一次的事件节点,那么系统就会放次该次的执行。CADisplayLink定义了一个和屏幕刷新频率相同的计时器。

PerformSelecter

当我门调用PerformXXX方法时,系统内部会自动创建一个timer去执行该事件。如果当前的线程没有runLoop,那么该事件便会失效

GCD与RunLoop

网络请求与RunLoop

常驻线程

计时器与滑动冲突

回光返照

      CFRunLoopRef runloop = CFRunLoopGetCurrent();
      NSArray* allModes =    CFBridgingRelease(CFRunLoopCopyAllModes(runLoop));
       while(1){
       for(NSString* mode in allModes ) {
        CFRunLoopRunInMode((CFStringRef)mode,0.001,false);
       }
       }

tableView卡顿优化

       [self.headImage performSelector:@selector(setImage:) withObject:downLoadImage delay:0 inMode:NSDefaultRunLoopMode];

参考文献:
coreFoundation源码： http://opensource.apple.com/tarballs/CF/CF-855.17.tar.gz
runLoop线下分享： http://www.ikoo8.com/video_play/XODgxODkzODI0.html

上一篇 下一篇

猜你喜欢

热点阅读