iOS:多线程编程指南(二)--Run Loops

--参考：（官网) https://developer.apple.com/library/ios/documentation/Cocoa/Conceptual/Multithreading/Introduction/Introduction.html + (中文翻译) http://www.cocoachina.com/bbs/read.php?tid=87592

=============Run Loops==========

        Run loops 是线程相关的的基础框架的一部分。一个 run loop 就是一个事件处理的循环,用来不停的调度工作以及处理输入事件。使用 run loop 的目的是让你的线 程在有工作的时候忙于工作,而没工作的时候处于休眠状态。
        Run loop 的管理并不完全自动的。你仍然需要设计你的线程代码在合适的时候启 动 run loop 并正确响应输入事件。Cocoa 和 Core Fundation 都提供了 run loop objects 来帮助配置和管理你线程的 run loop。你的应用程序不需要显式的创建这些对象(run loop objects);每个线程,包括程序的主线程都有与之对应的 run loop object。只有辅助线程(secondary threads)才需要显式(explicitly)的运行它的 run loop。在 Carbon 和 Cocoa 程序中, 主线程会自动创建并运行它 run loop,作为一般应用程序启动过程的一部分。
        以下各小节提供更多关于run loops内容以及如何为你的应用程序配置它们。关于 run loop object 的额外信息,参阅 NSRunLoop Class Reference 和 CFRunLoop Reference。

--------------Run Loop剖析(Anatomy)------------

         Run loop 本身听起来就和它的名字很像。它是一个循环,你的线程进入并使用它来运行事件处理(event handlers)响应输入事件。你的代码要提供实现循环部分的控制语句,换 言之就是要有 while 或 for 循环语句来驱动 run loop。在你的循环中,使用 run loop object to "run” the event-processing code that receives events and calls the installed handlers。
         Run loop 接收输入事件来自两种不同的来源:输入源(input source)和定时源 (timer source)。输入源传递异步事件,通常消息来自于其他线程或程序。定时源则传递同步事件,发生在特定时间或者重复的时间间隔。两种源都使用程序的某一特定的处理例程(application-specific handler routine)来处理到达的事件。
        下图显示了 run loop 的概念结构以及各种源。输入源传递异步消息给相应的handlers,并触发 runUntilDate:方法来退出(被线程里面associated NSRunLoop 对象调用)。定时源则直接传递消息给handler routines,但并不会引起 run loop退出。

         除了处理输入源,run loops 也会生成关于run loop行为的通知 (notifications)。注册的 run loop的观察者(run-loop Observers)可以收到这些通知, 并在线程上面使用它们来做额外的处理。你可以使用 Core Foundation 在你的线程注册 run-loop 观察者。
        下面将介绍更多关于 run loop 的构成,以及其运行的模式。同时也提及在处理事件中不同时间生成的通知。

------Run Loop 模式(Modes)------

        Run loop 模式是所有要监视的输入源和定时源（a collection of input sources and timers to be monitored）以及要通知的run loop注册观察者（a collection of run loop observers to be notified）的集合。每次运行你的 run loop,你都要指定(无论显示还是隐式)其运行个模式。在 run loop 运行过程中,只有和模式相关的源才会被监视并允许他们传递事件消息。(同样的,只有和模式相关的观察者会收到run loop 的通知)。和其他模式关联的源只有在run loop运行在相应模式下才会运行,否则处于暂停状态。
        通常在你的代码中,你可以通过指定名字来标识模式。Cocoa 和 Core foundation 定义了一个默认的和一些常用的模式,在你的代码中都是用字符串来标识这些模式。 当然你也可以给模式名称指定一个字符串来自定义模式。虽然你可以给模式指定任意名字,但是模式的内容则不能是任意的。你必须添加一个或多个输入源,定时源或者 run loop 的观察者到你新建的模式中让他们有价值。
        通过指定模式可以使得 run loop 在某一阶段过滤来源于unwanted sources 的事件。大多数时候, run loop 都是运行在系统定义的默认模式上。但是模态面板(modal panel)可以运行在 “modal”模式下。在这种模式下,只有和模式面板相关的源才可以传递消息给线程。对于辅助线程,你可以使用自定义模式在周期性操作上屏蔽优先级低的源传递消息。

         备注：模式区分基于事件的源而非事件的种类。例如,你不可以使用模式只选择处理鼠标按下或者键盘事件。你可以使用模式监听不同的端口,暂停定时器或者改变其他源和当前模式下处于监听状态 run loop 观察者

         下表列出了 Cocoa 和 Core Foundation 定义的标准模式,并且介绍何时使用他 们。名称列出了你用来在你代码中指定模式实际的常量。

mode	name	description
Default	NSDefaultRunLoopMode(Cocoa) kCFRunLoopDefaultMode (Core Foundation)	The default mode is the one used for most operations. Most of the time, you should use this mode to start your run loop and configure your input sources.
Connection	NSConnectionReplyMode(Cocoa)	Cocoa uses this mode in conjunction with NSConnection objects to monitor replies. You should rarely need to use this mode yourself
Modal	NSModalPanelRunLoopMode(Cocoa)	Cocoa uses this mode to identify events intended for modal panels.
Event tracking	NSEventTrackingRunLoopMode(Cocoa)	Cocoa uses this mode to restrict incoming events during mouse-dragging loops and other sorts of user interface tracking loops.
Common modes	NSRunLoopCommonModes(Cocoa) kCFRunLoopCommonModes (Core Foundation)	This is a configurable group of commonly used modes. Associating an input source with this mode also associates it with each of the modes in the group. For Cocoa applications, this set includes the default, modal, and event tracking modes by default. Core Foundation includes just the default mode initially. You can add custom modes to the set using the CFRunLoopAddCommonMode function

------输入源(Input Sources)------

       输入源异步的传送事件(deliver events asynchronously)给你的线程。事件来源取决于输入源的种类:基于端口的输入源(port-based input sources)和自定义输入源(Custom input sources )。基于端口的输入源监听程序相应的端口。自定义输入源则监听自定义的事件源。至于run loop,它不关心输入源的是基于端口的输入源还是自 定义的输入源。系统会实现两种输入源供你使用。两类输入源的区别在于如何发出信好(signaled): 基于端口的输入源由内核自动发送,而自定义的则需要人工从其他线程发送。
        当你创建输入源,你需要将其分配给 run loop 中的一个或多个模式。模式影响着输入源是否被监听。大多数情况下,run loop 运行在默认模式下,但是你也 可以使其运行在自定义模式。若某一源在当前模式下不被监听,那么任何其生成的事件将会被held，直到 run loop 运行在其关联的模式下。下文讲述不同输入源：

----基于端口的输入源:

         Cocoa 和 Core Foundation 内置支持使用 端口相关的对象和函数 来创建端口输入源。例如,在 Cocoa 里面你从来不需要直接创建输入源。你只要简单的创建端口对象(port object),并使用 NSPort 的方法把该端口添加到 run loop。端口对象会自己处理创建和配置输入源。
        在 Core Foundation,你必须人工创建端口和它的run loop 源.在两种情况下, 你都可以使用端口相关的函数(CFMachPortRef,CFMessagePortRef,CFSocketRef) 来创建合适的对象。更多关于如何设置和配置一个自定义端口源,参阅“配置一个基于端口的输入源”小节

----自定义输入源:

        为了创建自定义输入源,必须使用 Core Foundation 里面的 CFRunLoopSourceRef 类型相关的函数来创建。你配置自定义输入源通过使用几个回调函数。Core Fundation 会在不同地方调用回调函数，配置源、处理输入事件同时销毁源当它从 run loop 移除的时候。
        除了定义在事件到达时自定义输入源的行为,你也必须定义消息传递机制。这部分源运行在单独的线程里面,给输入源提供数据，并且在数据等待处理的时候发送信号。消息传递机制的定义取决于你,但最好不要过于复杂。
         关于创建自定义输入源的例子,参阅“定义一个自定义输入源”小节。关于自定义输入源的信息,参考 CFRunLoopSource Reference

----Cocoa 执行 Selector 的源(Cocoa Perform Selector Sources):

         除了基于端口的源,Cocoa 定义了自定义输入源,允许你在任何线程执行selector。和基于端口的源一样,执行 selector 请求会在目标线程上序列化，减缓在线程上多个方法同时运行引起的同步问题。不同于基于端口的源的是,一个 selector 执行完后会自动从 run loop 里面移除。

        注意:在 Mac OS X v10.5 之前,执行selector 多半可能是给主线程发送消息,但是在 Mac OS X v10.5 及其之后和在 iOS 里面,你可以使用它们给任何线程发送消息。

        当在其他线程上面执行 selector 时,目标线程须有一个活动的 run loop。对于 你创建的线程,这意味着线程在你显式的启动 run loop 之前处于等待状态。由于主线程自己启动它的 run loop,那么一旦程序通过委托调用 applicationDidFinishlaunching:的时候你将要调用那个线程。Run loop通过每次循环来处理所有队列的 selector的调用,而不是通过 loop 的迭代来一个个处理。
        下表列出了在NSObject 中定义的可在其它线程执行的 selector。由于这些方法时定义 在 NSObject 中,你可以在任何可以访问 Objective-C 对象的线程里面使用它们,包 括 POSIX 的所有线程。这些方法实际上并没有创建新的线程去执行selector。

performSelectorOnMainThread: withObject: waitUntilDone: performSelectorOnMainThread: withObject:waitUntilDone:modes:	Performs the specified selector on the application’s main thread during that thread’s next run loop cycle. These methods give you the option of locking the current thread until the selector is performed.
performSelector: onThread:withObject:waitUntilDone: performSelector: onThread:withObject:waitUntilDone:modes:	Performs the specified selector on any thread for which you have an NSThread object. These methods give you the option of blocking the current thread until the selector is performed.
performSelector: withObject: afterDelay: performSelector: withObject:afterDelay:inModes:	Performs the specified selector on the current thread during the next run loop cycle and after an optional delay period. Because it waits until the next run loop cycle to perform the selector, these methods provide an automatic mini delay from the currently executing code. Multiple queued selectors are performed one after another in the order they were queued.
cancelPreviousPerformRequestsWithTarget: cancelPreviousPerformRequestsWithTarget:selector:object:	Lets you cancel a message sent to the current thread using the performSelector: withObject: afterDelay: or performSelector: withObject: afterDelay:inModes: method.

          更多介绍这些方法的信息,参阅 NSObject Class Reference

------定时源(Timer Sources)------

         定时源在预设的时间点同步方式传递消息( deliver events synchronously)。定时器是线程通知自己做某事的一种方法。例如,搜索控件可以使用定时器,当用户连续输入的时间超过一定时间时,就开始一次搜索。这样的提前搜索利用延迟时间,就可以让用户在搜索前有足够的时间来输入想要搜索的关键字。
         尽管定时器可以产生基于时间的通知, 但它并不是实时机制。和输入源一样,定 时器也和你的 run loop的特定模式相关。如果定时器所在的模式当前未被 run loop监视,那么定时器将不会起作用(fire)，直到 run loop运行在相应的模式下。类似的,如果定时器在 run loop处理某一事件期间开始,定时器会一直等待，直到下次 run loop 开始相应的处理程序(handler routine)。如果 run loop不再运行,那定时器也将永远不启动。
       你可以配置定时器工作仅一次还是重复工作。 重复工作定时器会基于安排好的时间而非实际时间调度它自己运行。举个例子,如果定时器被设定在某一特定时间开始并 5 秒重复一次,那么定时器会在那个特定时间后 5 秒启动,即使在那个特定的触发时间延迟了。如果定时器被延迟以至于它错过了一个或多个触发时间,那么定时器会在下一个最近的触发事件启动,而后面会按照触发间隔正常执行。
        关于更多配置定时源的信息,参阅“ 配置定时源”小节。关于参考信息,查看 NSTimer Class Reference或 CFRunLoopTimer Reference

------Run Loop 观察者------

         相对于源source来说，观察者 fire 当合适的同步或异步事件发生时,run loop 观察者是在 run loop 本身运行的特定位置触发。你可以使用run loop 观察者来为线程处理某一特定事件或是现场进入休眠做准备。你可以将 run loop 观察者和以下事件关联:
--Run loop 入口
--当Run loop 处理一个定时器(a timer)的时候
--当Run loop 处理一个输入源(an input source)的时候
--当Run loop 进入睡眠状态的时候
--当Run loop 被唤醒,但在要处理唤醒事件之前的时候
--Run loop 终止；

        你可以给 run loop观察者添加到程序里面使用Core Fundation 。创建一个 run loop 观察者,你得创建一个 CFRunLoopObserverRef 类型的实例。它会追踪你自定义的回调函数以及其它你感兴趣的活动。
        和定时器类似,run loop 观察者也可以只用一次或循环使用。若只用一次,那么在它启动后,会把它自己从 run loop 里面移除，而循环的观察者则不会。你在创建 run loop观察者的时候需要指定它是运行一次还是多次。
         关于如何创建一个run loop观察者的实例,参阅“ 配置run loop”小节。更多的相关信息,参阅 CFRunLoopObserver Reference。

------Run Loop 的事件队列-------

        每次运行 run loop,你线程的run loop会处理之前未处理的消息,并通知相关的观察者。它工作的顺序比较特殊，具体如下:
1. 通知观察者 run loop已经启动
2. 通知观察者任何定时器即将要开始
3. 通知观察者任何非基于端口的源(any input sources that are not port based)即将启动
4. 启动任何准备好的非基于端口的(non-port-based input sources)源
5. 如果基于端口的源准备好并处于等待状态,立即启动;并进入步骤 9。
6. 通知观察者线程进入休眠
7. 将线程置于休眠直到任一下面的事件发生:
--某一事件到达基于端口的源
--定时器启动
--Run loop 设置的时间已经超时 

--run loop 被显式唤醒
8. 通知观察者线程将被唤醒。
9. 处理未处理的事件
--如果用户定义的定时器启动,处理定时器事件并重启 run loop。进入步骤 2 

--如果输入源启动,传递相应的消息
--如果 run loop 被显式唤醒而且时间还没超时,重启 run loop。进入步骤 2 

10. 通知观察者 run loop 结束。
        因为定时器和输入源的观察者是在相应的事件发生之前传递消息,所以通知的时间和实际事件发生的时间之间可能存在误差。如果需要精确时间控制,你可以使用休眠和唤醒的通知来帮助你校对实际发生事件的时间。
        因为当你运行 run loop 时定时器和其它周期性事件经常需要被传递,撤销run loop会终止消息传递。典型的例子就是通过entering a loop and repeatedly requesting events from the application实现鼠标路径追踪(mouse-tracking routine)。因为你的代码直接获取到消息而不是经由程序正常传递(dispatch those events normally),因此活跃的定时器不会开始直到鼠标追踪结束并将控制权交给程序。
        Run loop可以由 run loop 对象显式(explicitly)唤醒。其它事件也可以唤醒run loop。例如, 添加新的非基于端口的源会唤醒 run loop，从而可以立即处理输入源而不需要等待其他事件发生后再处理。

------------何时使用 Run Loop------------

        仅当在为你的程序 创建辅助线程(secondary threads)的时候,你才需要显式运行一个run loop。Run loop是程序主线程基础设施(infrastructure)的关键部分。所以程序框架提供了代码运行主程序的循环并自动启动run loop。IOS 程序中UIApplication 的 run 方法(或 Mac OS X 中的NSApplication)作为程序启动步骤的一部分 ,它在程序正常启动的时候就会启动程序的主循环。如果你使用 xcode 提供的模板创建你的程序,那你永远不需要自己去显式的调用这些例程/代码(call these routines explicitly)。
        对于辅助线程,你需要判断一个 run loop 是否是必须的。如果是必须的,那么你要自己配置并启动它。你不需要在任何情况下都去启动一个线程的run loop。比如,你使用线程来处理一个预先定义的长时间运行的任务时,你应该避免启动run loop。Run loop在你要和线程有更多的交互时才需要,比如以下情况:
--使用端口或自定义输入源来和其他线程通信

--使用线程的定时器
--在Cocoa程序中使用任何 performSelector...的方法

--使线程周期性工作

        如果你决定在程序中使用 run loop,那么它的配置和启动都很简单。和所有线程编程一样,你需要计划好在辅助线程退出的情形。让线程自然退出往往比强制关闭它更好。更多介绍如何配置和退出一个 run loop,参考” 使用Run Loop对象” 小节

------------使用 Run Loop 对象-----------

       Run loop 对象提供了添加输入源,定时器和 run loop 的观察者以及启动 run loop的接口。每个线程都有唯一的与之关联的 run loop对象。在Cocoa 中,该对象是 NSRunLoop 类的一个实例;而在更低级的程序中则是一个指向 CFRunLoopRef 类型的指针。

-----获得 Run Loop对象------

         为了获得当前线程的 run loop,你可以采用以下任一方式:
--在 Cocoa 程序中,使用 NSRunLoop的  currentRunLoop类方法来取得( retrieve)一个NSRunLoop 对象。
--使用 CFRunLoopGetCurrent 函数。
        虽然它们并不是完全相同的类型,但是你可以在需要的时候从 NSRunLoop 对象中 获取 CFRunLoopRef 类型。NSRunLoop 类定义了一个 getCFRunLoop 方法,该方法返回 一个可以传递给 Core Foundation 程序( routines)的 CFRunLoopRef 类型。因为两者都指向同一 个 run loop,你可以在需要的时候混合使用 NSRunLoop 对象和CFRunLoopRef ( opaque type)类型。

------配置Run Loop-------

            在你在辅助线程运行run loop之前， 你必须至少添加一输入源或定时器给它。如果run loop没有任何源需要监视的话，它会在你启动之际立马退出。关于如何添加源到run loop里面的例子，参考” 配置Run Loop源(Sources)”。
            除了安装源，你也可以添加run loop观察者来监视run loop的不同执行阶段情况。为了给run loop添加一个观察者，你可以创建CFRunLoopObserverRef不透明类型（opaque type），并使用CFRunLoopAddObserver将它添加到你的run loop。Run loop观察者必须由Core foundation函数创建，即使是Cocoa程序。
           以下代码shows the main routine for a thread that attaches a run loop observer to its run loop。该例子的主要目的是显示如何创建一个run loop观察者，所以该代码只是简单的设置一个观察者来监视run loop的所有活动。The basic handler routine (not shown) simply logs the run loop activity as it processes the timer requests。

- (void)threadMain
{
    // The application uses garbage collection, so no autorelease pool is needed.
    NSRunLoop* myRunLoop = [NSRunLoop currentRunLoop];
   // Create a run loop observer and attach it to the run loop.
   CFRunLoopObserverContext context = {0, self, NULL, NULL, NULL};
   CFRunLoopObserverRef observer = CFRunLoopObserverCreate(kCFAllocatorDefault,kCFRunLoopAllActivities, YES, 0, &myRunLoopObserver, &context);
if (observer)
{
    CFRunLoopRef cfLoop = [myRunLoop getCFRunLoop];
    CFRunLoopAddObserver(cfLoop, observer, kCFRunLoopDefaultMode);
}
   // Create and schedule the timer.
   [NSTimer scheduledTimerWithTimeInterval:0.1 target:self selector:@selector(doFireTimer:) userInfo:nil repeats:YES];
   NSInteger loopCount = 10;
   do
   {
    // Run the run loop 10 times to let the timer fire.
    [myRunLoop runUntilDate:[NSDate dateWithTimeIntervalSinceNow:1]];
     loopCount--;
   }
   while (loopCount);
}

            When configuring the run loop for a long-lived thread, it is better to add at least one input source to receive messages. Although you can enter the run loop with only a timer attached, once the timer fires, it is typically  invalidated, which would then cause the run loop to exit. Attaching a repeating timer could keep the run loop running over a longer period of time, but would involve firing the timer periodically to wake your thread, 这实际上是轮询（polling）的另一种形式而已. By contrast, an input source waits for an event to happen, keeping your thread asleep until it does.

------启动Run Loop------  

         启动run loop只对程序的secondary threads有意义。一个run loop通常必须包含一个输入源或定时器来监听事件。如果一个都没有，run loop启动后立即退出。
有几种方式可以启动run loop,包括以下这些:
--Unconditionally
--With a set time limit

--In a particular mode
          “无条件”进入run loop是 最简单的方法，但也最不推荐使用的。因为这样会使你的线程处在一个永久的循环中，这会让你对run loop本身的控制很少。你可以添加或删除输入源和定时器， 但是退出run loop的唯一方法是杀死它。没有任何办法可以让这run loop运行在自定义模式下。
          替代“无条件”进入run loop更好的办法是用预设超时时间来运行run loop，这样 run loop运作直到某一事件到达或者规定的时间已经到期。如果是事件到达，消息会被传递给相应的处理程序来处理(event is dispatched to a handler for processing)，然后run loop退出。你可以重新启动run loop来等待下一事件。如果是规定时间到期了，你只需简单的重启run loop或使用此段时间来做任何的其他工作。
         除了超时机制，你也可以使用特定的模式来运行你的run loop。 模式和超时不是互斥的，他们可以在启动run loop的时候同时使用。模式限制了可以传递事件给run loop的输入源的类型，详见” Run Loop模式”小节。

         以下代码描述了线程的main entry的架构。本示例的关键是说明了run loop的基本结构。本质上讲你添加自己的输入源或定时器到run loop里面，然后重复的调用一个routines来启动run loop。Each time the run loop routine returns, you check to see if any conditions have arisen that might warrant exiting the thread. The example uses the Core Foundation  run loop routines so that it can check the return result and determine why the run loop exited. You could also use the methods of the NSRunLoop class to run the run loop in a similar manner if you are using Cocoa and do not need to check the return value.

- (void)skeletonThreadMain
{
     // Set up an autorelease pool here if not using garbage collection.
     BOOL done = NO;
     // Add your sources or timers to the run loop and do any other setup.
    do
    {
       // Start the run loop but return after each source is handled.
       SInt32 result = CFRunLoopRunInMode(kCFRunLoopDefaultMode, 10, YES);
       // If a source explicitly stopped the run loop, or if there are no
       // sources or timers, go ahead and exit.
       if ((result == kCFRunLoopRunStopped) || (result == kCFRunLoopRunFinished))
       done = YES;
       // Check for any other exit conditions here and set the
       // done variable as needed.
    }
    while (!done);
    // Clean up code here. Be sure to release any allocated autorelease pools.
}

         可以递归的运行run loop。换句话说你可以使用CFRunLoopRun，CFRunLoopRunInMode或者任一NSRunLoop的方法在输入源或定时器的处理程序里面启动run loop。这样做的话，你可以使用任何模式启动嵌套的run loop，包括被外层run loop使用的模式。

--退出Run Loop

        有两种方法可以让run loop处理事件之前退出：

--Configure the run loop to run with a timeout value.

--Tell the run loop to stop.

         如果可以选择的话， 推荐使用第一种方法。指定一个超时时间可以使run loop退出前完成所有正常操作，包括发送消息给run loop观察者。
        使用CFRunLoopStop来显式的停止run loop和使用超时时间产生的结果相似。Run loop把所有剩余的通知发送出去再退出。 The difference is that you can use this technique on run loops you started unconditionally.

       尽管移除run loop的输入源和定时器也可能导致run loop退出，但这并不是可靠的退出run loop的方法。一些 system routines会添加输入源到run loop里面来处理所需事件。因为你的代码未必会考虑到这些输入源，这样可能导致你无法没从系统例程中移除它们，从而导致退出run loop。

------线程安全和Run Loop对象------

          线程是否安全取决于你使用那些API来操纵你的run loop。 Core Foundation 中的函数通常是线程安全的，可以被任意线程调用。If you are performing operations that
alter the configuration of the run loop, however, it is still good practice to do so from the thread that owns the run loop whenever possible.。
          至于Cocoa的NSRunLoop类则不像Core Foundation具有与生俱来的线程安全性。如果你想使用NSRunLoop类来修改你的run loop，你应用在run loop所属的线程里面完成这些操作。给属于不同线程的run loop添加输入源和定时器有可能导致你的代码崩溃或产生不可预知的行为。

-------------配置Run loop的源(Sources)------------

         以下部分列举了在Cocoa和Core Foundation里面如何设置不同类型的输入源的例子

------定义自定义输入源(Custom Input Source)------

          创建自定义的输入源包括定义以下内容：
--The information you want your input source to process.
--A scheduler routine to let interested clients know how to contact your input source.
--A handler routine to perform requests sent by any clients.
--A cancellation routine to invalidate your input source.
         由于你自己创建输入源to process custom information，实际配置应该设计to be flexible。调度例程，处理例程和取消例程（ scheduler, handler, and cancellation routines)都是你创建自定义输入源时最关键的例程。然而输入源其他的大部分行为都发生在这些例程的外部。比如，由你决定数据传输到输入源的机制，还有输入源和其他线程的通信机制也是由你决定。
         下图shows a sample configuration of a custom input source. In this example, the application’s main thread maintains references to the input source, the custom command buffer for that input source, and the  run loopon which the input source is installed. When the main thread has a task it wants to hand off to the worker thread, it posts a command to the command buffer along with any information needed by the worker thread to start the task. ( Because both the main thread and the input source of the worker thread have access to the command buffer, that access must be synchronized.) Once the command is posted, the main thread signals the input source and wakes up the worker thread’s run loop. Upon receiving the wake up command, the run loop calls the handler for the input source, which processes the commands found in the command buffer.

        以下部分解释上图的实现自定义输入源关键部分和你需要实现的关键代码

----Defining the Input Source

         Defining a custom input source requires the use of Core Foundation routines to configure your run loop source and attach it to a run loop.尽管这些基本的处理例程(handlers)是基于C的函数，但并不排除你可以对这些函数进行封装，并使用Objective-C或Objective-C++来实现你代码的主体。

         上图中的的输入源uses an Objective-C object to manage a command buffer and coordinate with the run loop.。下面代码给出了该对象的定义。RunLoopSource对象管理着command buffer并以此来接收其他线程的消息。代码同样给出了RunLoopContext对象的定义，它是一个用于传递RunLoopSource对象和run loop引用给程序主线程的一个容器。

@interface RunLoopSource : NSObject
{
   CFRunLoopSourceRef runLoopSource;
   NSMutableArray* commands;
}
- (id)init;
- (void)addToCurrentRunLoop;
- (void)invalidate;
// Handler method
- (void)sourceFired;
// Client interface for registering commands to process
- (void)addCommand:(NSInteger)command withData:(id)data;
- (void)fireAllCommandsOnRunLoop:(CFRunLoopRef)runloop;
@end
// These are the CFRunLoopSourceRef callback functions.
void RunLoopSourceScheduleRoutine (void *info, CFRunLoopRef rl, CFStringRef mode);
void RunLoopSourcePerformRoutine (void *info);
void RunLoopSourceCancelRoutine (void *info, CFRunLoopRef rl, CFStringRef mode);
// RunLoopContext is a container object used during registration of the input source.
@interface RunLoopContext : NSObject
{
    CFRunLoopRef runLoop;
    RunLoopSource* source;
}
@property (readonly) CFRunLoopRef runLoop;
@property (readonly) RunLoopSource* source;
- (id)initWithSource:(RunLoopSource*)src andLoop:(CFRunLoopRef)loop;
@end

           尽管使用Objective-C代码来管理 the custom data of the input source, attaching the input source to a run loop requires C-based callback functions。当你正在把你的run loop源附加到run loop的时候，使用下面代码中的第一个函数（RunLoopSourceScheduleRoutine）。因为这个输入源只有一个客户端client（即主线程），它使用调度函数(scheduler function) to send a message to register itself with the application delegate on that thread. When the delegate wants to communicate with the input source, it uses the information  in RunLoopContext object to do so.

void RunLoopSourceScheduleRoutine (void *info, CFRunLoopRef rl, CFStringRef mode)
{
RunLoopSource* obj = (RunLoopSource*)info;
AppDelegate* del = [AppDelegate sharedAppDelegate];
RunLoopContext* theContext = [[RunLoopContext alloc] initWithSource:obj andLoop:rl];
[del performSelectorOnMainThread:@selector(registerSource:) withObject:theContext waitUntilDone:NO];
}

          一个最重要的callback routines is the one used to process custom data when your input source is signaled。下面代码shows the perform callback routine associated with the RunLoopSource object。这个函数只是简单的发送了一个请求to do the work通过调用sourceFired 方法。然后继续处理在命令缓存区出现的命令。

void RunLoopSourcePerformRoutine (void *info)
{
RunLoopSource* obj = (RunLoopSource*)info;
[obj sourceFired];
}

        如果你使用CFRunLoopSourceInvalidate函数把输入源从run loop里面移除的话，the system calls your input source’s cancellation routine。You can use this routine to notify clients that your  input source is no longer valid and that they should remove any references to it。下面代码shows the cancellation callback routine registered with the RunLoopSource object. This function sends another RunLoopContext object to the application delegate, but this time asks the delegate to remove references to
the run loop source。

void RunLoopSourceCancelRoutine (void *info, CFRunLoopRef rl, CFStringRef mode)
{
RunLoopSource* obj = (RunLoopSource*)info;
AppDelegate* del = [AppDelegate sharedAppDelegate];
RunLoopContext* theContext = [[RunLoopContext alloc] initWithSource:obj andLoop:rl];
[del performSelectorOnMainThread:@selector(removeSource:) withObject:theContext waitUntilDone:YES];
}

-----安装Input Source到Run Loop

           下面代码显示了RunLoopSource的init和addToCurrentRunLoop的方法。Init方法创建CFRunLoopSourceRef的不透明类型(opaque type)，该类型必须被附加到run loop里面。它把RunLoopSource对象做为上下文引用参数(as the contextual information)，以便回调例程持有该对象的一个引用指针。输入源的安装只在工作线程调用 addToCurrentRunLoop方法才发生，此时RunLoopSourceScheduledRoutine被调用。一旦输入源被添加到run loop，线程可以运行its run loop并等待事件。

- (id)init
{
CFRunLoopSourceContext context = {0, self, NULL, NULL, NULL, NULL, NULL,&RunLoopSourceScheduleRoutine,RunLoopSourceCancelRoutine,RunLoopSourcePerformRoutine};
runLoopSource = CFRunLoopSourceCreate(NULL, 0, &context);
commands = [[NSMutableArray alloc] init];
return self;
}
- (void)addToCurrentRunLoop
{
CFRunLoopRef runLoop = CFRunLoopGetCurrent();
CFRunLoopAddSource(runLoop, runLoopSource, kCFRunLoopDefaultMode);
}

-----Coordinating with Clients of the Input Source(协调输入源的客户端)

         为了让添加的输入源有用，你需要维护它并从其他线程给它发送信号。输入源的主要工作就是将与输入源相关的线程置于休眠状态直到有事件发生。这就意味着程序中的要有其他线程知道该输入源信息并有办法与之通信。
         通知客户端关于你输入源信息的方法之一就是当你的输入源开始安装到你的run loop上面后发送注册请求。你可以把输入源注册到任意数量的客户端(You can register your input source with as many clients as you want)，或者you can simply register it with some central agency that then vends your input source to interested clients。下面代码显示the registration method defined by the application delegate and invoked when the RunLoopSource  object’s scheduler function is called. This method receives the RunLoopContext object provided by the RunLoopSource object and adds it to its list of sources. This listing also shows the routine used to unregister the input source when it is removed from its run loop.

- (void)registerSource:(RunLoopContext*)sourceInfo;
{
  [sourcesToPing addObject:sourceInfo];
}
- (void)removeSource:(RunLoopContext*)sourceInfo
{
   id objToRemove = nil;
for (RunLoopContext* context in sourcesToPing)
{
   if ([context isEqual:sourceInfo])
   {
       objToRemove = context;
        break;
   }
}
   if (objToRemove)
   [sourcesToPing removeObject:objToRemove];
}

       注意：该回调函数调用了之前代码中描述的方法。

------Signaling the Input Source通知输入源

         After it hands off its data to the input source, a client must signal the source and wake up its run loop. Signaling the source lets the run loop know that the source is ready to be processed. And because the thread might be asleep when the signal occurs, you should always wake up the run loop explicitly. Failing to do so might result
in a delay in processing the input source.

         下面代码显示了RunLoopSource对象的fireCommandsOnRunLoop方法。Clients invoke this method when they are ready for the source to process the commands they added to the buffer。

- (void)fireCommandsOnRunLoop:(CFRunLoopRef)runloop
{
CFRunLoopSourceSignal(runLoopSource);
CFRunLoopWakeUp(runloop);
}

         备注：你不应该试图通过自定义输入源处理一个SIGHUP或其他进程级别类型的信号。Core Foundation唤醒run loop的函数不是信号安全的，不能在你的应用信号处理例程里面使用。关于更多信号处理例程（signal handler routines），参阅sigaction主页。

------配置Timer Sources------

         为了创建一个定时源，你所需要做只是创建一个定时器对象并把它调度到你的run loop。在Cocoa中使用NSTimer类来创建一个新的定时器对象，而Core Foundation中使用CFRunLoopTimerRef  opaque type。本质上，NSTimer类是Core Foundation的简单扩展，它提供了便利的特征，例如能使用相同的方法创建和调配定时器。
         Cocoa中可以使用以下NSTimer类方法来创建并调配一个定时器：
--scheduledTimerWithTimeInterval:target:selector:userInfo:repeats:
--scheduledTimerWithTimeInterval:invocation:repeats:
         上述方法创建了定时器并以默认模式(NSDefaultRunLoopMode).)把它们添加到当前线程的run loop。你可以手工的创建NSTimer对象，并通过NSRunLoop的addTimer:forMode:把它添加到run loop。两种方法都做了相同的事，区别在于你对定时器配置的控制权。例如，如果你手工创建定时器并把它添加到run loop，你可以选择要添加的模式而不使用默认模式。下面代码显示了如何使用这这两种方法创建定时器。第一个定时器在初始化后1秒开始运行，此后每隔0.1秒运行。第二个定时器则在初始化后0.2秒开始运行，此后每隔0.2秒运行：

NSRunLoop* myRunLoop = [NSRunLoop currentRunLoop];
// Create and schedule the first timer.
NSDate* futureDate = [NSDate dateWithTimeIntervalSinceNow:1.0];
NSTimer* myTimer = [[NSTimer alloc] initWithFireDate:futureDate interval:0.1 target:self selector:@selector(myDoFireTimer1:) userInfo:nil repeats:YES];
[myRunLoop addTimer:myTimer forMode:NSDefaultRunLoopMode];

// Create and schedule the second timer.
[NSTimer scheduledTimerWithTimeInterval:0.2 target:self selector:@selector(myDoFireTimer2:) userInfo:nil repeats:YES];

        下面代码 显示了使用Core Foundation函数来配置定时器的代码。尽管这个例子中并没有把任何用户定义的信息作为上下文结构( user-defined information in the context structure)，但是你可以使用这个上下文结构传递任何你想传递的信息给定时器。关于该结构的内容的详细信息，参阅 CFRunLoopTimer Reference

CFRunLoopRef runLoop = CFRunLoopGetCurrent();
CFRunLoopTimerContext context = {0, NULL, NULL, NULL, NULL};
CFRunLoopTimerRef timer = CFRunLoopTimerCreate(kCFAllocatorDefault, 0.1, 0.3, 0,0,&myCFTimerCallback, &context);
CFRunLoopAddTimer(runLoop, timer, kCFRunLoopCommonModes);

-------Configuring a Port-Based Input Source基于端口的输入源--------

           Cocoa和Core Foundation都提供了基于端口的对象用于线程或进程间的通信。以下部分显示如何使用几种不同类型的端口对象建立端口通信。

------配置NSMachPort对象

          为了和NSMachPort对象建立稳定的本地连接，你需要创建端口对象并将之加入相应的线程的run loop。当运行secondary thread的时候，你传递端口对象到thread's entry-point function。secondary thread可以使用相同的端口对象将消息返回给原线程。

---Implementing the Main Thread Code:

          下面代码显示了the primary thread code for launching a secondary worker thread。因为Cocoa框架performs many of the intervening steps配置端口和run loop，所以lauchThread方法比相应的Core Foundation版本(之后的代码)要明显简短。然而两种方法的本质几乎是一样的，唯一的区别就是在Cocoa中直接发送NSPort对象，而不是发送本地端口名称。

- (void)launchThread
{
   NSPort* myPort = [NSMachPort port];
   if (myPort)
  {
     // This class handles incoming port messages.
     [myPort setDelegate:self];
     // Install the port as an input source on the current run loop.
     [[NSRunLoop currentRunLoop] addPort:myPort forMode:NSDefaultRunLoopMode];
     // Detach the thread. Let the worker release the port.
     [NSThread detachNewThreadSelector:@selector(LaunchThreadWithPort:) toTarget:[MyWorkerClass class] withObject:myPort];
    }
   }

       为了在你的线程间建立双向的通信，you might want to have the worker thread send its own local port to your main thread in a check-in message. Receiving the check-in message lets your main thread know that all went well in launching the second thread and also gives you a way to send further messages to that thread。

         下面代码显示了主要线程的handlePortMessage：方法。 This method is called when data arrives on the thread's own local port. When a check-in message arrives, the method retrieves the port  for the secondary thread directly from the port message and saves it for later use。

#define kCheckinMessage 100
// Handle responses from the worker thread.
- (void)handlePortMessage:(NSPortMessage *)portMessage
{
   unsigned int message = [portMessage msgid];
   NSPort* distantPort = nil;
   if (message == kCheckinMessage)
   {
      // Get the worker thread’s communications port.
     distantPort = [portMessage sendPort];
    // Retain and save the worker port for later use.
    [self storeDistantPort:distantPort];
   }
   else
   {
    // Handle other messages.
   }
}

-------Implementing the Secondary Thread Code

          对于辅助工作线程，you must configure the thread and use the specified port to communicate information back to the primary thread.。

          下面代码显示了如何设置工作线程的代码。创建了线程的自动释放池后，紧接着创建工作对象驱动线程运行。工作对象的sendCheckinMessage：方法（如之后代码所示）创建了工作线程的本地端口并发送签到消息回主线程（creates a local port for the worker thread and sends a check-in message back to the main thread）。

+(void)LaunchThreadWithPort:(id)inData
{
    NSAutoreleasePool*  pool = [[NSAutoreleasePool alloc] init];
 
    // Set up the connection between this thread and the main thread.
    NSPort* distantPort = (NSPort*)inData;
 
    MyWorkerClass*  workerObj = [[self alloc] init];
    [workerObj sendCheckinMessage:distantPort];
    [distantPort release];
 
    // Let the run loop process things.
    do
    {
        [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode
                            beforeDate:[NSDate distantFuture]];
    }
    while (![workerObj shouldExit]);
 
    [workerObj release];
    [pool release];
}

         当使用NSMachPort时候，本地和远程线程可以使用相同的端口对象在线程间进行单边通信。换句话说，the local port object created by one thread becomes the remote port  object for the other thread。

        下面代码shows the check-in routine of the secondary thread. This method sets up its own local port for  future communication and then sends a check-in message back to the main thread. The method uses the port  object received in the LaunchThreadWithPort: method as the target of the message。

// Worker thread check-in method
- (void)sendCheckinMessage:(NSPort*)outPort
{
    // Retain and save the remote port for future use.
    [self setRemotePort:outPort];
 
    // Create and configure the worker thread port.
    NSPort* myPort = [NSMachPort port];
    [myPort setDelegate:self];
    [[NSRunLoop currentRunLoop] addPort:myPort forMode:NSDefaultRunLoopMode];
 
    // Create the check-in message.
    NSPortMessage* messageObj = [[NSPortMessage alloc] initWithSendPort:outPort
                                         receivePort:myPort components:nil];
 
    if (messageObj)
    {
        // Finish configuring the message and send it immediately.
        [messageObj setMsgId:setMsgid:kCheckinMessage];
        [messageObj sendBeforeDate:[NSDate date]];
    }
}

------配置NSMessagePort对象          

         为了和NSMeaasgePort的建立稳定的本地连接，你不能简单的在线程间传递端口对象。远程消息端口必须通过名字来获得。在Cocoa中这需要你registering your local port with a specific name，并将名字传递到远程线程以便远程线程可以获得合适的端口对象用于通信。下面代码shows the port creation and registration process in cases where you want to use message ports。

NSPort* localPort = [[NSMessagePort alloc] init];
 
// Configure the object and add it to the current run loop.
[localPort setDelegate:self];
[[NSRunLoop currentRunLoop] addPort:localPort forMode:NSDefaultRunLoopMode];
 
// Register the port using a specific name. The name must be unique.
NSString* localPortName = [NSString stringWithFormat:@"MyPortName"];
[[NSMessagePortNameServer sharedInstance] registerPort:localPort
                     name:localPortName];

-------Configuring a Port-Based Input Source in Core Foundation

          这部分介绍了在Core Foundation中如何在程序主线程和工作线程(a worker thread)间建立双通道通信(two-way communications channel)。

          具体内容详见官网！