NSURLConnection–(底层)–>AFNetworking
dispatch_get_main_queue()
CADisplaLink CATransition CAAnimation
NSObject(NSDelayedPerforming) 、NSObject(NSTreadPerformAddition)
…

2. RunLoop机制

NSRunLoop是CFRunLoop的封装，直接看CF(Core Foundation)这一层就好.

RunLoop与线程和释放池之间的关系：

苹果不允许直接创建RunLoop，它只提供了两个自动获取的函数：CFRunLoopGetMain()和CGRunLoopGetCurrent()。这两个函数内部逻辑大概是下面这样：

/// 全局的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());
}

CFRunLoop与Thread的关系：
CFRunLoop与线程是一一绑定的关系（或者理解为RunLoop寄生于线程），一个线程自能有唯一对应的runloop；但是这个根runloop里可以嵌套子runloops。从上面的代码中我们可以看到，线程和RunLoop保存在一个全局的Dictionary里（Dic={@“线程”：@“RunLoop”}）。线程刚创建时并没有RunLoop，如果你不主动获取，那它一直都不会有。RunLoop的创建是发生在第一次获取时，RunLoop的销毁是发生在线程结束时。你只能在一个线程的内部获取其RunLoop（主线程除外）。
CFRunLoop与释放池的关系：
自动释放池寄生于RunLoop。程序启动后，主线程注册了两个Observer监听runloop的进出与休眠。一个最高级Observer监听Entry状态；一个最低级Observer监听BeforeWaiting状态和Exit状态。

线程(创建)–>runloop将进入–>最高优先级OB创建释放池–>runloop将睡–>最低优先级OB销毁旧池创建新池–>runloop将退出–>最低优先级OB销毁新池–>线程(销毁)

3. CFRunLoopRef的构造：

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<Source/Observer/Timer>
    CFRunLoopModeRef _currentMode;    // Current Runloop Mode
    CFMutableSetRef _modes;           // Set
    ...
};

这里有个概念叫 “CommonModes”：一个 Mode 可以将自己标记为”Common”属性（通过将其 ModeName 添加到 RunLoop 的 “commonModes” 中）。每当 RunLoop 的内容发生变化时，RunLoop 都会自动将 _commonModeItems 里的 Source/Observer/Timer 同步到具有 “Common” 标记的所有Mode里。

应用场景举例：主线程的 RunLoop 里有两个预置的 Mode：kCFRunLoopDefaultMode 和 UITrackingRunLoopMode。这两个 Mode 都已经被标记为”Common”属性。DefaultMode 是 App 平时所处的状态，TrackingRunLoopMode 是追踪 ScrollView 滑动时的状态。当你创建一个 Timer 并加到 DefaultMode 时，Timer 会得到重复回调，但此时滑动一个TableView时，RunLoop 会将 mode 切换为 TrackingRunLoopMode，这时 Timer 就不会被回调，并且也不会影响到滑动操作。
有时你需要一个 Timer，在两个 Mode 中都能得到回调，一种办法就是将这个 Timer 分别加入这两个 Mode。还有一种方式，就是将 Timer 加入到顶层的 RunLoop 的 “commonModeItems” 中。”commonModeItems” 被 RunLoop 自动更新到所有具有”Common”属性的 Mode 里去。

一个 RunLoop 包含若干个 Mode，每个 Mode 又包含若干个 Source/Timer/Observer。每次调用 RunLoop 的主函数时，只能指定其中一个 Mode，这个Mode被称作 CurrentMode。如果需要切换 Mode，只能退出 Loop，再重新指定一个 Mode 进入。这样做主要是为了分隔开不同组的 Source/Timer/Observer，让其互不影响。

4. CFRunLoopModelRef：

数据构造 （见上）
创建与添加 ：runloop自动创建对应的mode；mode只能添加不能删除

1	CFRunLoopAddCommonMode(CFRunLoopRef runloop, CFStringRef modeName);// 添加mode

类型：

1. kCFRunLoopDefaultMode: 默认 mode，通常主线程在这个 Mode 下运行。
2. UITrackingRunLoopMode: 追踪mode，保证Scrollview滑动顺畅不受其他 mode 影响。
3. UIInitializationRunLoopMode: 启动程序后的过渡mode，启动完成后就不再使用。
4: GSEventReceiveRunLoopMode: Graphic相关事件的mode，通常用不到。
5: kCFRunLoopCommonModes: 占位mode，作为标记DefaultMode和CommonMode用。

modeItems ：

// 添加移除item的函数（参数：添加/移除哪个item到哪个runloop的哪个mode下）CFRunLoopAddSource(CFRunLoopRef rl, CFRunLoopSourceRef source, CFStringRef modeName);
CFRunLoopAddObserver(CFRunLoopRef rl, CFRunLoopObserverRef observer, CFStringRef modeName);
CFRunLoopAddTimer(CFRunLoopRef rl, CFRunLoopTimerRef timer, CFStringRef mode);
CFRunLoopRemoveSource(CFRunLoopRef rl, CFRunLoopSourceRef source, CFStringRef modeName);
CFRunLoopRemoveObserver(CFRunLoopRef rl, CFRunLoopObserverRef observer, CFStringRef modeName);
CFRunLoopRemoveTimer(CFRunLoopRef rl, CFRunLoopTimerRef timer, CFStringRef mode);

你只能通过 mode name 来操作内部的 mode，当你传入一个新的 mode name 但 RunLoop 内部没有对应 mode 时，RunLoop会自动帮你创建对应的 CFRunLoopModeRef。对于一个 RunLoop 来说，其内部的 mode 只能增加不能删除。
苹果公开提供的 Mode 有两个：kCFRunLoopDefaultMode (NSDefaultRunLoopMode) 和 UITrackingRunLoopMode，你可以用这两个 Mode Name 来操作其对应的 Mode。
同时苹果还提供了一个操作 Common 标记的字符串：kCFRunLoopCommonModes (NSRunLoopCommonModes)，你可以用这个字符串来操作 Common Items，或标记一个 Mode 为 “Common”。使用时注意区分这个字符串和其他 mode name。

4.1 CFRunLoopSourceRef:

数据构造

// source0 (manual): order(优先级)，callout(回调函数)
CFRunLoopSource {order =..., {callout =... }}
// source1 (mach port)：order(优先级)，port:(端口), callout(回调函数)
CFRunLoopSource {order = ..., {port = ..., callout =...}

• Source0 只包含了一个回调（函数指针），它并不能主动触发事件。使用时，你需要先调用 CFRunLoopSourceSignal(source)，将这个 Source 标记为待处理，然后手动调用 CFRunLoopWakeUp(runloop) 来唤醒 RunLoop，让其处理这个事件。
• Source1 包含了一个 mach_port 和一个回调（函数指针），被用于通过内核和其他线程相互发送消息。这种 Source 能主动唤醒 RunLoop 的线程，其原理在下面会讲到。

4.2 CFRunLoopTimerRef:

CFRunLoopTimerRef 是基于时间的触发器，它和 NSTimer 是toll-free bridged 的，可以混用。其包含一个时间长度和一个回调（函数指针）。当其加入到 RunLoop 时，RunLoop会注册对应的时间点，当时间点到时，RunLoop会被唤醒以执行那个回调。
数据构造

1 2	// Timer：interval:(闹钟间隔), tolerance:(延期时间容忍度)，callout(回调函数) CFRunLoopTimer {firing =..., interval = ...,tolerance = ...,next fire date = ...,callout = ...}

创建与生效

//NSTimer：// 创建一个定时器（需要手动加到runloop的mode中）
+ (NSTimer *)timerWithTimeInterval:(NSTimeInterval)ti invocation:(NSInvocation *)invocation repeats:(BOOL)yesOrNo; // 默认已经添加到主线程的runLoop的DefaultMode中 
+ (NSTimer *)scheduledTimerWithTimeInterval:(NSTimeInterval)ti invocation:(NSInvocation *)invocation repeats:(BOOL)yesOrNo;// performSEL方法// 内部会创建一个Timer到当前线程的runloop中（如果当前线程没runloop则方法无效；performSelector:onThread: 方法放到指定线程runloop中）
- (void)performSelector:(SEL)aSelector withObject:(id)anArgument afterDelay:(NSTimeInterval)delay

相关类型（GCD的timer与CADisplayLink)
GCD的timer：dispatch_source_t 类型，可以精确的参数，不用以来runloop和mode，性能消耗更小。

dispatch_source_set_timer(dispatch_source_t source, // 定时器对象dispatch_time_t start, // 定时器开始执行的时间uint64_t interval, // 定时器的间隔时间uint64_t leeway // 定时器的精度 );

CADisplayLink ：Timer的tolerance表示最大延期时间，如果因为阻塞错过了这个时间精度，这个时间点的回调也会跳过去，不会延后执行。CADisplayLink 是一个和屏幕刷新率一致的定时器，如果在两次屏幕刷新之间执行了一个长任务，那其中就会有一帧被跳过去（和 NSTimer 相似，只是没有tolerance容忍时间），造成界面卡顿的感觉。

4.3 CFRunLoopObserverRef:

监听runloop状态，接收回调信息（常见于自动释放池创建销毁）

数据构造

1 2	// Observer：order(优先级)，ativity(监听状态)，callout(回调函数) CFRunLoopObserver {order = ..., activities = ..., callout = ...}

创建与添加

// 第一个参数用于分配该observer对象的内存空间
// 第二个参数用以设置该observer监听什么状态
// 第三个参数用于标识该observer是在第一次进入run loop时执行还是每次进入run loop处理时均执行
// 第四个参数用于设置该observer的优先级,一般为0
// 第五个参数用于设置该observer的回调函数
// 第六个参数observer的运行状态 CFRunLoopObserverCreateWithHandler(CFAllocatorGetDefault(), kCFRunLoopAllActivities, YES, 0, ^(CFRunLoopObserverRef observer, CFRunLoopActivity activity) { // 执行代码}

监听的状态

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

5. RunLoop 内部逻辑：

关键在两个判断点（是否睡觉，是否退出）

代码实现

// RunLoop的实现int CFRunLoopRunSpecific(runloop, modeName, seconds, stopAfterHandle) { 
// 0.1 根据modeName找到对应mode 
CFRunLoopModeRef currentMode = __CFRunLoopFindMode(runloop, modeName, false); 
// 0.2 如果mode里没有source/timer/observer, 直接返回。if (__CFRunLoopModeIsEmpty(currentMode)) return; 
// 1.1 通知 Observers: RunLoop 即将进入 loop。---（OB会创建释放池）__CFRunLoopDoObservers(runloop, currentMode, kCFRunLoopEntry); 
// 1.2 内部函数，进入loop__CFRunLoopRun(runloop, currentMode, seconds, returnAfterSourceHandled) {
Boolean sourceHandledThisLoop = NO;
int retVal = 0; 
do { 
// 2.1 通知 Observers: RunLoop 即将触发 Timer 回调。__CFRunLoopDoObservers(runloop, currentMode, kCFRunLoopBeforeTimers); 
// 2.2 通知 Observers: RunLoop 即将触发 Source0 (非port) 回调。__CFRunLoopDoObservers(runloop, currentMode, kCFRunLoopBeforeSources); 
// 执行被加入的block__CFRunLoopDoBlocks(runloop, currentMode); 
// 2.3 RunLoop 触发 Source0 (非port) 回调。
sourceHandledThisLoop = __CFRunLoopDoSources0(runloop, currentMode, stopAfterHandle); 
// 执行被加入的block__CFRunLoopDoBlocks(runloop, currentMode); 
// 2.4 如果有 Source1 (基于port) 处于 ready 状态，直接处理这个 Source1 然后跳转去处理消息。if (__Source0DidDispatchPortLastTime) {
Boolean hasMsg = __CFRunLoopServiceMachPort(dispatchPort, &msg) 
if (hasMsg) goto handle_msg; } 
// 3.1 如果没有待处理消息，通知 Observers: RunLoop 的线程即将进入休眠(sleep)。--- (OB会销毁释放池并建立新释放池)if (!sourceHandledThisLoop) { 
__CFRunLoopDoObservers(runloop, currentMode, kCFRunLoopBeforeWaiting); } 
// 3.2. 调用 mach_msg 等待接受 mach_port 的消息。线程将进入休眠, 直到被下面某一个事件唤醒。// - 一个基于 port 的Source1 的事件。// - 一个 Timer 到时间了// - RunLoop 启动时设置的最大超时时间到了// - 被手动唤醒__CFRunLoopServiceMachPort(waitSet, &msg, sizeof(msg_buffer), &livePort) { 
mach_msg(msg, MACH_RCV_MSG, port); // thread wait for receive msg } 
// 3.3. 被唤醒，通知 Observers: RunLoop 的线程刚刚被唤醒了。__CFRunLoopDoObservers(runloop, currentMode, kCFRunLoopAfterWaiting); 
// 4.0 处理消息。
handle_msg: 
// 4.1 如果消息是Timer类型，触发这个Timer的回调。
if (msg_is_timer) { 
__CFRunLoopDoTimers(runloop, currentMode, mach_absolute_time()) } 
// 4.2 如果消息是dispatch到main_queue的block，执行block。
else if (msg_is_dispatch) { __CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__(msg); }
// 4.3 如果消息是Source1类型，处理这个事件
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); 
// 5.1 如果处理事件完毕，启动Runloop时设置参数为一次性执行,设置while参数退出Runloopif (sourceHandledThisLoop && stopAfterHandle) { 
retVal = kCFRunLoopRunHandledSource; 
// 5.2 如果启动Runloop时设置的最大运转时间到期，设置while参数退出Runloop 
}  else if (timeout) { 
retVal = kCFRunLoopRunTimedOut; 
// 5.3 如果启动Runloop被外部调用强制停止，设置while参数退出Runloop 
} else if (__CFRunLoopIsStopped(runloop)) { 
retVal = kCFRunLoopRunStopped; 
// 5.4 如果启动Runloop的modeItems为空，设置while参数退出Runloop 
} else if (__CFRunLoopModeIsEmpty(runloop, currentMode)) {
retVal = kCFRunLoopRunFinished; }
// 5.5 如果没超时，mode里没空，loop也没被停止，那继续loop，回到第2步循环。
} while (retVal == 0); } 
// 6. 如果第6步判断后loop退出，通知 Observers: RunLoop 退出。--- (OB会销毁新释放池)__CFRunLoopDoObservers(rl, currentMode, kCFRunLoopExit);
}
``` 
* **简化实现过程**

1- Entry：通知OB（创建pool）；
2- 执行阶段：按顺序通知OB并执行timer，source0；若有source1执行source1；
3- 休眠阶段：利用mach_msg判断进入休眠，通知OB（pool的销毁重建）；被消息唤醒通知OB；
4- 执行阶段：按消息类型处理事件；
5- 判断退出条件：如果符合退出条件（一次性执行，超时，强制停止，modeItem为空）则退出，否则回到第2阶段；
6- Exit：通知OB（销毁pool）。

1	# 6. RunLoop 本质：mach port和mach_msg()

Mach是XNU的内核，进程、线程和虚拟内存等对象通过端口发消息进行通信，Runloop通过mach_msg()函数发送消息，如果没有port 消息，内核会将线程置于等待状态 mach_msg_trap() 。
如果有消息，判断消息类型处理事件，并通过modeItem的callback回调。

1
2
3

# 7. RunLoop如何处理事件（举例
* **界面刷新**

当UI改变（ Frame变化、 UIView/CALayer 的继承结构变化等）时，或手动调用了 UIView/CALayer 的 setNeedsLayout/setNeedsDisplay方法后，这个 UIView/CALayer 就被标记为待处理。
苹果注册了一个用来监听BeforeWaiting和Exit的Observer，在它的回调函数里会遍历所有待处理的 UIView/CAlayer 以执行实际的绘制和调整，并更新 UI 界面。

1	* 事件响应

当一个硬件事件(触摸/锁屏/摇晃/加速等)发生后，首先由 IOKit.framework 生成一个 IOHIDEvent 事件并由 SpringBoard 接收，随后由mach port 转发给需要的App进程。
苹果注册了一个 Source1 (基于 mach port 的) 来接收系统事件，通过回调函数触发Sourece0（所以UIEvent实际上是基于Source0的），
调用 _UIApplicationHandleEventQueue() 进行应用内部的分发。_UIApplicationHandleEventQueue() 会把 IOHIDEvent 处理并包装成 UIEvent 进行处理或分发，其中包括识别 UIGesture/处理屏幕旋转/发送给 UIWindow 等。

1	* 手势识别

如果上一步的 _UIApplicationHandleEventQueue() 识别到是一个guesture手势，会调用Cancel方法将当前的touchesBegin/Move/End 系列回调打断。随后系统将对应的 UIGestureRecognizer 标记为待处理。
苹果注册了一个 Observer 监测 BeforeWaiting (Loop即将进入休眠) 事件，其回调函数为 _UIGestureRecognizerUpdateObserver()，其内部会获取所有刚被标记为待处理的 GestureRecognizer，并执行GestureRecognizer的回调。
当有 UIGestureRecognizer 的变化(创建/销毁/状态改变)时，这个回调都会进行相应处理。

1 2	* GCD任务

当调用 dispatch_async(dispatch_get_main_queue(), block) 时，libDispatch 会向主线程的 RunLoop 发送消息，RunLoop会被唤醒，并从消息中取得这个 block，并在回调里执行这个 block。Runloop只处理主线程的block，dispatch 到其他线程仍然是由 libDispatch 处理的。

1 2	* 网络请求

关于网络请求的接口:最底层是CFSocket层，然后是CFNetwork将其封装，然后是NSURLConnection对CFNetwork进行面向对象的封装，NSURLSession 是 iOS7 中新增的接口，也用到NSURLConnection的loader线程。所以还是以NSURLConnection为例。
当开始网络传输时，NSURLConnection 创建了两个新线程：com.apple.NSURLConnectionLoader 和 com.apple.CFSocket.private。其中 CFSocket 线程是处理底层 socket 连接的。NSURLConnectionLoader 这个线程内部会使用 RunLoop 来接收底层 socket 的事件，并通过之前添加的 Source0 通知到上层的 Delegate。

![666982-9bf4831b87769d5a.png](http://upload-images.jianshu.io/upload_images/1438251-974107aba47b23f5.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
# 8.应用
* **滑动与图片刷新**
当tableview的cell上有需要从网络获取的图片的时候，滚动tableView，异步线程会去加载图片，加载完成后主线程就会设置cell的图片，但是会造成卡顿。可以让设置图片的任务在CFRunLoopDefaultMode下进行，当滚动tableView的时候，RunLoop是在 UITrackingRunLoopMode 下进行，不去设置图片，而是当停止的时候，再去设置图片。

(void)viewDidLoad {
[super viewDidLoad];
// 只在NSDefaultRunLoopMode下执行(刷新图片)
[self.myImageView performSelector:@selector(setImage:) withObject:[UIImage imageNamed:@””] afterDelay:ti inModes:@[NSDefaultRunLoopMode]];
}

1 2	* 常驻子线程，保持子线程一直处理事件为了保证线程长期运转，可以在子线程中加入RunLoop，并且给Runloop设置item，防止Runloop自动退出。

(void)networkRequestThreadEntryPoint:(id)__unused object {
@autoreleasepool {
[[NSThread currentThread] setName:@”AFNetworking”];
NSRunLoop *runLoop = [NSRunLoop currentRunLoop];
[runLoop addPort:[NSMachPort port] forMode:NSDefaultRunLoopMode];
[runLoop run];
}
}
(NSThread )networkRequestThread {
static NSThread _networkRequestThread = nil;
static dispatch_once_t oncePredicate;
dispatch_once(&oncePredicate, ^{
_networkRequestThread = [[NSThread alloc] initWithTarget:self selector:@selector(networkRequestThreadEntryPoint:) object:nil];
[_networkRequestThread start]; });
return _networkRequestThread;}

(void)start {
[self.lock lock];
if ([self isCancelled]) {
[self performSelector:@selector(cancelConnection) onThread:[[self class] networkRequestThread] withObject:nil waitUntilDone:NO modes:[self.runLoopModes allObjects]];
} else if ([self isReady]) {
self.state = AFOperationExecutingState;
[self performSelector:@selector(operationDidStart) onThread:[[self class] networkRequestThread] withObject:nil waitUntilDone:NO modes:[self.runLoopModes allObjects]];
}
[self.lock unlock];
}

```

荼菜的ios笔记–精解runloop笔记 2. RunLoop机制 RunLoop与线程和释放池之间的关系： 3. CFRunLoopRef的构造： 4. CFRunLoopModelRef： 5. RunLoop 内部逻辑：

2. RunLoop机制

RunLoop与线程和释放池之间的关系：

3. CFRunLoopRef的构造：

4. CFRunLoopModelRef：

4.1 CFRunLoopSourceRef:

4.2 CFRunLoopTimerRef:

4.3 CFRunLoopObserverRef:

5. RunLoop 内部逻辑：

近期文章

近期评论

标签

热门

文章归档

分类目录

功能