首先看一段AF2.x经典代码:
+ (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)networkRequestThreadEntryPoint:(id)__unused object {
@autoreleasepool {
[[NSThread currentThread] setName:@"AFNetworking"];
NSRunLoop *runLoop = [NSRunLoop currentRunLoop];
[runLoop addPort:[NSMachPort port] forMode:NSDefaultRunLoopMode];
[runLoop run];
}
}
这里创建了一个线程,取名为AFNetworking,因为添加了一个runloop,所以这个线程不会被销毁,直到runloop停止。
[runLoop addPort:[NSMachPort port] forMode:NSDefaultRunLoopMode];
[runLoop run];
[NSRunLoop currentRunLoop]removePort:<#(nonnull NSPort *)#> forMode:<#(nonnull NSRunLoopMode)#>
再次回到AF2.x的这行源码上,因为他用的是run,而且并没有记录下自己添加的NSMachPort,所以显然,它就没打算退出这个runloop,这是一个常驻线程。事实上,看过AF2.x源码的同学会知道,这个thread需要常驻的原因,在此就不做赘述了。
接下来我们看看AF3.x是怎么用runloop的:
需要开启的时候:
CFRunLoopRun();
终止的时候:
CFRunLoopStop(CFRunLoopGetCurrent());
再看看RAC中的runloop:
do {
[NSRunLoop.mainRunLoop runMode:NSDefaultRunLoopMode beforeDate:[NSDate dateWithTimeIntervalSinceNow:0.1]];
} while (!done);
以上我们都大致分析一下,后面我们再来讲为什么。
首先我们先讲讲runloop的概念:
runloop官方图.png
-(BOOL)runMode:(NSString *)mode beforeDate:(NSDate *)limitDate
方法运行在某个特定模式mode。
我们先来谈谈Runloop Mode
OS下Run Loop的主要运行模式mode有:
将UITrackingRunLoopMode或者其他模式添加到这个NSRunLoopCommonModes模式中,然后只需要将Timer关联到NSRunLoopCommonModes,即可以实现Run Loop运行在这个模式集合中任何一个模式时,这个Timer都可以被触发。
总结一下:
Run Loop运行时只能以一种固定的模式运行,如果我们需要它切换模式,只有停掉它,再重新开启它。
运行时它只会监控这个模式下添加的Timer Source和Input Source,如果这个模式下没有相应的事件源,Run Loop的运行也会立刻返回的。注意Run Loop不能在运行在NSRunLoopCommonModes模式,因为NSRunLoopCommonModes其实是个模式集合,而不是一个具体的模式,我可以在添加事件源的时候使用NSRunLoopCommonModes,只要Run Loop运行在NSRunLoopCommonModes中任何一个模式,这个事件源都可以被触发。
Run Loop运行接口
NSRunLoop的运行接口:
//运行 NSRunLoop,运行模式为默认的NSDefaultRunLoopMode模式,没有超时限制
- (void)run;
//运行 NSRunLoop: 参数为运时间期限,运行模式为默认的NSDefaultRunLoopMode模式
- (void)runUntilDate:(NSDate *)limitDate;
//运行 NSRunLoop: 参数为运行模式、时间期限,返回值为YES表示是处理事件后返回的,NO表示是超时或者停止运行导致返回的
- (BOOL)runMode:(NSString *)mode beforeDate:(NSDate *)limitDate;
CFRunLoopRef的运行接口:
//运行 CFRunLoopRef
void CFRunLoopRun();
//运行 CFRunLoopRef: 参数为运行模式、时间和是否在处理Input Source后退出标志,返回值是exit原因
SInt32 CFRunLoopRunInMode (mode, seconds, returnAfterSourceHandled);
//停止运行 CFRunLoopRef
void CFRunLoopStop( CFRunLoopRef rl );
//唤醒CFRunLoopRef
void CFRunLoopWakeUp ( CFRunLoopRef rl );
首先,详细讲解下NSRunLoop的三个运行接口:
first
- (void)run; 无条件运行
second
- (void)runUntilDate:(NSDate *)limitDate; 有一个超时时间限制
while (!Done)
{
[[NSRunLoop currentRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:10]];
NSLog(@"exiting runloop.........:");
}
third
//有一个超时时间限制,而且设置运行模式
- (BOOL)runMode:(NSString *)mode beforeDate:(NSDate *)limitDate;
CFRunLoopStop(runloopRef)
所停止的(大家可以自己写个例子试试)。- (void)testDemo1
{
dispatch_async(dispatch_get_global_queue(0, 0), ^{
NSLog(@"线程开始");
//获取到当前线程
self.thread = [NSThread currentThread];
NSRunLoop *runloop = [NSRunLoop currentRunLoop];
//添加一个Port,同理为了防止runloop没事干直接退出
[runloop addPort:[NSMachPort port] forMode:NSDefaultRunLoopMode];
//运行一个runloop,[NSDate distantFuture]:很久很久以后才让它失效
[runloop runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]];
NSLog(@"线程结束");
});
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
//在我们开启的异步线程调用方法
[self performSelector:@selector(recieveMsg) onThread:self.thread withObject:nil waitUntilDone:NO];
});
}
- (void)recieveMsg
{
NSLog(@"收到消息了,在这个线程:%@",[NSThread currentThread]);
}
输出结果如下
2016-11-22 14:04:15.250 TestRunloop3[70591:1742754] 线程开始
2016-11-22 14:04:17.250 TestRunloop3[70591:1742754] 收到消息了,在这个线程:{number = 3, name = (null)}
2016-11-22 14:04:17.250 TestRunloop3[70591:1742754] 线程结束
在这里我们用了performSelector: onThread...这个方法去进行线程间通信,这只是其中一种最简单的方式。但是缺点也很明显,就是在去调用这个线程的时候,如果线程已经不存在了,程序就会crash。后面我们会仔细讲各种线程间的通信。
我们看到,我们收到了一个消息,这个消息是一个非timer的事件,所以runloop处理完就退出了,这里为什么会这样呢,我们可以看看runloop的源代码:
/// 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;
}
/// 6.通知 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);
/// 9.收到消息,处理消息。
handle_msg:
/// 10.1 如果一个 Timer 到时间了,触发这个Timer的回调。
if (msg_is_timer) {
__CFRunLoopDoTimers(runloop, currentMode, mach_absolute_time())
}
/// 10.2 如果有dispatch到main_queue的block,执行block。
else if (msg_is_dispatch) {
__CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__(msg);
}
/// 10.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);
}
/// 11. 通知 Observers: RunLoop 即将退出。
__CFRunLoopDoObservers(rl, currentMode, kCFRunLoopExit);
}
代码一长串,但是标了注释,应该大致能看明白,大概讲一下:
__CFRunLoopServiceMachPort(waitSet, &msg, sizeof(msg_buffer), &livePort)
{
// thread wait for receive msg
mach_msg(msg, MACH_RCV_MSG, port);
}
这一行类似sync这样的一个同步机制(其实不是,举个例子。。),把程序阻塞在这一行,直到有消息返回值,才继续往下进行。这一阻塞操作是系统内核来挂起的,阻塞了当前的线程,当有消息返回时,因为当前线程是被阻塞的,系统内核会再开辟一个新的线程去返回这个消息。然后程序继续往下进行。
回到上述的例子这种模式下的runloop:
- (BOOL)runMode:(NSString *)mode beforeDate:(NSDate *)limitDate;
我们让线程执行了一个事件,结果执行完,runloop就退出了,原因原来是这样:
if (sourceHandledThisLoop && stopAfterHandle)
{
/// 进入loop时参数说处理完事件就返回。
retVal = kCFRunLoopRunHandledSource;
}
/// 10.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);
}
}
所以在这里我们触发了事件之后,runloop被退出了,这时候我们也明白了为什么timer并不会导致runloop的退出。
接下来我们分析一下Core Foundation中运行runloop的接口:
//运行 CFRunLoopRef
void CFRunLoopRun();
//运行 CFRunLoopRef: 参数为运行模式、时间和是否在处理Input Source后退出标志,返回值是exit原因
SInt32 CFRunLoopRunInMode (mode, seconds, returnAfterSourceHandled);
//停止运行 CFRunLoopRef
void CFRunLoopStop( CFRunLoopRef rl );
//唤醒 CFRunLoopRef
void CFRunLoopWakeUp ( CFRunLoopRef rl );
first:
void CFRunLoopRun();
- (BOOL)runMode:(NSString *)mode beforeDate:(NSDate *)limitDate;
这方式运行的runloop也能用CFRunLoopStop
停止掉的原因它是完全基于下面这种方式封装的:
SInt32 CFRunLoopRunInMode (mode, seconds, returnAfterSourceHandled);
可以看到参数几乎一模一样,前者默认returnAfterSourceHandled参数为YES,当触发一个非timer事件后,runloop就终止了。
second:
SInt32 CFRunLoopRunInMode (mode, seconds, returnAfterSourceHandled);
enum {
kCFRunLoopRunFinished = 1, //Run Loop结束,没有Timer或者其他Input Source
kCFRunLoopRunStopped = 2, //Run Loop被停止,使用CFRunLoopStop停止Run Loop
kCFRunLoopRunTimedOut = 3, //Run Loop超时
kCFRunLoopRunHandledSource = 4 ////Run Loop处理完事件,注意Timer事件的触发是不会让Run Loop退出返回的,即使CFRunLoopRunInMode的第三个参数是YES也不行
};
看到这,我们发现我们忽略了NSRunloop第三种开启方式的返回值。- (BOOL)runMode:(NSString *)mode beforeDate:(NSDate *)limitDate;
它其实就是基于CFRunLoopRunInMode封装的,它的返回值为一个Bool值,如果是PerfromSelector***事件或者其他Input Source事件触发处理后,Run Loop会退出返回YES,其他返回NO。
举个例子:
- (void)testDemo2
{
dispatch_async(dispatch_get_global_queue(0, 0), ^{
NSLog(@"starting thread.......");
NSTimer *timer = [NSTimer timerWithTimeInterval:1 target:self selector:@selector(doTimerTask1:) userInfo:remotePort repeats:YES];
[[NSRunLoop currentRunLoop] addTimer:timer forMode:NSDefaultRunLoopMode];
//最后一个参数,是否处理完事件返回,结束runLoop
SInt32 result = CFRunLoopRunInMode(kCFRunLoopDefaultMode, 100, YES);
/*
kCFRunLoopRunFinished = 1, //Run Loop结束,没有Timer或者其他Input Source
kCFRunLoopRunStopped = 2, //Run Loop被停止,使用CFRunLoopStop停止Run Loop
kCFRunLoopRunTimedOut = 3, //Run Loop超时
kCFRunLoopRunHandledSource = 4 ////Run Loop处理完事件,注意Timer事件的触发是不会让Run Loop退出返回的,即使CFRunLoopRunInMode的第三个参数是YES也不行
*/
switch (result) {
case kCFRunLoopRunFinished:
NSLog(@"kCFRunLoopRunFinished");
break;
case kCFRunLoopRunStopped:
NSLog(@"kCFRunLoopRunStopped");
case kCFRunLoopRunTimedOut:
NSLog(@"kCFRunLoopRunTimedOut");
case kCFRunLoopRunHandledSource:
NSLog(@"kCFRunLoopRunHandledSource");
default:
break;
}
NSLog(@"end thread.......");
});
}
- (void)doTimerTask1:(NSTimer *)timer
{
count++;
if (count == 2) {
[timer invalidate];
}
NSLog(@"do timer task count:%d",count);
}
输出结果如下:
2016-11-23 09:19:28.342 TestRunloop3[88598:1971412] starting thread.......
2016-11-23 09:19:29.347 TestRunloop3[88598:1971412] do timer task count:1
2016-11-23 09:19:30.345 TestRunloop3[88598:1971412] do timer task count:2
2016-11-23 09:19:30.348 TestRunloop3[88598:1971412] kCFRunLoopRunFinished
2016-11-23 09:19:30.348 TestRunloop3[88598:1971412] end thread.......
总结一下:
void CFRunLoopStop( CFRunLoopRef rl );
去停止。NSRunLoop
下面这个方法运行也能使用void CFRunLoopStop( CFRunLoopRef rl );
停止:[NSRunLoop currentRunLoop]runMode:<#(nonnull NSRunLoopMode)#> beforeDate:<#(nonnull NSDate *)#>```
- 实际过程中,可以根据需求,我们可以设置一个自己的Bool值,来控制runloop的开始与停止,类似下面这样:
while (!cancel) {
CFRunLoopRunInMode(kCFRunLoopDefaultMode, 1, YES);
}
- 每次runloop只运行1秒就停止,然后开始下一次的runloop。
- 这里最后一个参数设置为YES,当有非timer事件进来,也会立即开始下一次runloop。
- 当然每次进来我们都可以去修改Mode的值,这样我们可以让runloop每次都运行在不同的模式下。
- 当我们不需要runloop的时候,直接将cancel置为YES即可。
当然,这里只是提供一个思路,具体有需求,可以根据实际需要。
#####基于runloop的线程通信
首先明确一个概念,线程间的通信(不仅限于通信,几乎所有iOS事件都是如此),实际上是各种输入源,触发runloop去处理对应的事件,所以我们先来讲讲输入源:
输入源异步的发送消息给你的线程。事件来源取决于输入源的种类:
- 基于端口的输入源和自定义输入源。基于端口的输入源监听程序相应的端口。自定义输入源则监听自定义的事件源。
至于run loop,它不关心输入源的是基于端口的输入源还是自定义的输入源。系统会实现两种输入源供你使用。两类输入源的区别在于:
- 基于端口的输入源由内核自动发送,而自定义的则需要人工从其他线程发送。
当你创建输入源,你需要将其分配给run loop中的一个或多个模式。模式只会在特定事件影响监听的源。大多数情况下,run loop运行在默认模式下,但是你也可以使其运行在自定义模式。若某一源在当前模式下不被监听,那么任何其生成的消息只在run loop运行在其关联的模式下才会被传递。
1)基于端口的输入源:
在runloop中,被定义名为souce1。Cocoa和Core Foundation内置支持使用端口相关的对象和函数来创建的基于端口的源。例如,在Cocoa里面你从来不需要直接创建输入源。你只要简单的创建端口对象,并使用NSPort的方法把该端口添加到run loop。端口对象会自己处理创建和配置输入源。
在Core Foundation,你必须人工创建端口和它的run loop源.在两种情况下,你都可以使用端口相关的函数(CFMachPortRef,CFMessagePortRef,CFSocketRef)来创建合适的对象。
这里用Cocoa里的举个例子,Cocoa里用来线程间传值的是NSMachPort,它的父类是NSPort。
首先我们看下面:
NSPort *port1 = [[NSPort alloc]init];
NSPort *port2 = [[NSMachPort alloc]init];
NSPort *port3 = [NSPort port];
NSPort *port4 = [NSMachPort port];
我们打断点可以看到如下:
![port图.png](http://upload-images.jianshu.io/upload_images/2702646-6364a8544aa941b3.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
- 发现我们怎么创建,都返回给我们的是NSMachPort的实例,这应该是NSPort内部做了一个消息的转发,这就有点像是一个抽象类了,它本身只是定义一些公有的属性和方法,然后利用集成它的子类去实现(只是我个人猜测。。)
继续看我们写的一个利用NSMachPort来线程通信的实例:
(void)testDemo3
{
//声明两个端口 随便怎么写创建方法,返回的总是一个NSMachPort实例
NSMachPort *mainPort = [[NSMachPort alloc]init];
NSPort *threadPort = [NSMachPort port];
//设置线程的端口的代理回调为自己
threadPort.delegate = self;
//给主线程runloop加一个端口
[[NSRunLoop currentRunLoop]addPort:mainPort forMode:NSDefaultRunLoopMode];
dispatch_async(dispatch_get_global_queue(0, 0), ^{
//添加一个Port
[[NSRunLoop currentRunLoop]addPort:threadPort forMode:NSDefaultRunLoopMode];
[[NSRunLoop currentRunLoop]runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]];
});
NSString *s1 = @"hello";
NSData *data = [s1 dataUsingEncoding:NSUTF8StringEncoding];
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
NSMutableArray *array = [NSMutableArray arrayWithArray:@[mainPort,data]];
//过2秒向threadPort发送一条消息,第一个参数:发送时间。msgid 消息标识。
//components,发送消息附带参数。reserved:为头部预留的字节数(从官方文档上看到的,猜测可能是类似请求头的东西...)
[threadPort sendBeforeDate:[NSDate date] msgid:1000 components:array from:mainPort reserved:0];
});
}
//这个NSMachPort收到消息的回调,注意这个参数,可以先给一个id。如果用文档里的NSPortMessage会发现无法取值
(void)handlePortMessage:(id)message
{
NSLog(@"收到消息了,线程为:%@",[NSThread currentThread]);
//只能用KVC的方式取值
NSArray *array = [message valueForKeyPath:@"components"];
NSData *data = array[1];
NSString *s1 = [[NSString alloc]initWithData:data encoding:NSUTF8StringEncoding];
NSLog(@"%@",s1);
// NSMachPort *localPort = [message valueForKeyPath:@"localPort"];
// NSMachPort *remotePort = [message valueForKeyPath:@"remotePort"];
}
打印如下:
2016-11-23 16:50:20.604 TestRunloop3[1322:120162] 收到消息了,线程为:
2016-11-23 16:50:26.551 TestRunloop3[1322:120162] hello
- 我们跨越线程,确实从主线程往另一个线程发送了消息。
- 这里要注意几个点:
1)```- (void)handlePortMessage:(id)message```这里这个代理的参数,从.h里去复制过来的为NSPortMessage类型的一个对象,但是我们发现苹果只是在.h中@class进来,我们无法调用它的任何方法。所以我们用id声明,然后通过KVC去取它的属性。
2)关于下面这个传值类型的问题:
```NSMutableArray *array = [NSMutableArray arrayWithArray:@[mainPort,data]];```
作者在这困惑了好一会。。之前我是往数组里添加的是String或者其他类型的对象,但是发现参数传过去之后,变成nil了。于是去百度查了半天,然后没有结果。。于是去翻官方文档,终于在方法描述里看到(其实很醒目。。然而作者英文水平实在有限。。):
> The components array consists of a series of instances
of some subclass of NSData, and instances of some
subclass of NSPort; since one subclass of NSPort does
not necessarily know how to transport an instance of
another subclass of NSPort (or could do it even if it
knew about the other subclass), all of the instances
of NSPort in the components array and the 'receivePort'
argument MUST be of the same subclass of NSPort that
receives this message. If multiple DO transports are
being used in the same program, this requires some care.
从这段描述中我们可以看出,**这个传参数组里面只能装两种类型的数据,一种是NSPort的子类,一种是NSData的子类。**所以我们如果要用这种方式传值必须得先把数据转成NSData类型的才行。
2)Cocoa 执行 Selector 的源:
- 除了基于端口的源,Cocoa定义了自定义输入源,允许你在任何线程执行selector。它被称为source0,和基于端口的源一样,执行selector请求会在目标线程上序列化,减缓许多在线程上允许多个方法容易引起的同步问题。不像基于端口的源,一个selector执行完后会自动从run loop里面移除。
- 有方法如下:
[self performSelectorOnMainThread:<#(nonnull SEL)#> withObject:<#(nullable id)#> waitUntilDone:<#(BOOL)#>]
[self performSelectorOnMainThread:<#(nonnull SEL)#> withObject:<#(nullable id)#> waitUntilDone:<#(BOOL)#> modes:<#(nullable NSArray
[self performSelector:<#(nonnull SEL)#> onThread:<#(nonnull NSThread *)#> withObject:<#(nullable id)#> waitUntilDone:<#(BOOL)#>]
[self performSelector:<#(nonnull SEL)#> onThread:<#(nonnull NSThread *)#> withObject:<#(nullable id)#> waitUntilDone:<#(BOOL)#> modes:<#(nullable NSArray
- 这四个方法很类似,一个是在主线程去掉,一个可以指定一个线程。然后一个带Mode,一个不带。
- 大概讲一下 waitUntilDone 这个参数,顾名思义,就是是否等到结束。
1)如果这个值设为YES,那么就需要等到这个方法执行完,线程才能继续往下去执行。它会阻塞提交的线程。
2)如果为NO的话,这个调用的方法会异步的实行,不会阻塞提交线程。
方法比较简单,就不举例说明了。
3) 自定义输入源:
- 为了自定义输入源,必须使用 Core Foundation里面的 CGRunLoopSourceRef类型相关的函数来创建。你可以使用回调函数来配置自定义输入源。Corefondation 会在配置源的不同地方调用回调函数,处理输入时间,在源从 runloop 移除的时候清理它。
除了定义在事件到达时自定义输入源的行为,你也必须定义消息传递机制。源的这部分运行在单独的线程里面,并负责在数据等待处理的时候传递数据给源并源并通知它处理数据。消息传递机制的定义取决于你,但是最好不要过于复杂。
创建自定义的输入源包括定义以下内容:
1.输入源要处理的信息。
2.使感兴趣的客户端知道如何和输入源交互的调度例程。
3.处理其他任何客户端发送请求的例程。
4.使输入源失效的取消例程。
- 由于创建输入源来处理自定义消息,实际配置选是灵活配置的。调度例程,处理例程和取消例程都是创建自定义输入源是最关键的例程。二输入源其他的大部分行为都发生在这些例程的外部。比如,由于你决定数据传输到输入源的机制,还有输入源和其他线程的通信机制也是由你决定。
下图中,程序的主线程维护了一个输入源的引用,输入源所需的自定义命令缓冲区和输入源所在的 runloop。当主线程有任务需要分发给工作线程时候,***主线程会给命令缓冲区发送命令和必须的信息来通知工作线程开始执行任务。(因为主线程和输入源所在工作线程都可以访问命令缓冲区,因此这些访问必须是同步的)***一旦命令传送出去,主线程会通知输入源并且唤醒工作线程的 runloop。而一收到唤醒命令,runloop 会调用输入源的处理程序,由它来执行命令缓冲区中响应的命令。
![自定义输入源.png](http://upload-images.jianshu.io/upload_images/2702646-532788b8b08ec601.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
还是一样,我们来写一个实例来讲讲自定义的输入源(注:自定义输入源,只有用CF来实现):
CFRunLoopRef _runLoopRef;
CFRunLoopSourceRef _source;
CFRunLoopSourceContext _source_context;
首先我们声明3个成员变量,这是我们自定义输入源所需要的3个参数。具体我们举完例子之后再说。
(void)testDemo4
{
dispatch_async(dispatch_get_global_queue(0, 0), ^{
NSLog(@"starting thread.......");
_runLoopRef = CFRunLoopGetCurrent();
//初始化_source_context。
bzero(&_source_context, sizeof(_source_context));
//这里创建了一个基于事件的源,绑定了一个函数
_source_context.perform = fire;
//参数
_source_context.info = "hello";
//创建一个source
_source = CFRunLoopSourceCreate(NULL, 0, &_source_context);
//将source添加到当前RunLoop中去
CFRunLoopAddSource(_runLoopRef, _source, kCFRunLoopDefaultMode);
//开启runloop 第三个参数设置为YES,执行完一次事件后返回
CFRunLoopRunInMode(kCFRunLoopDefaultMode, 9999999, YES);
NSLog(@"end thread.......");
});
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
if (CFRunLoopIsWaiting(_runLoopRef)) {
NSLog(@"RunLoop 正在等待事件输入");
//添加输入事件
CFRunLoopSourceSignal(_source);
//唤醒线程,线程唤醒后发现由事件需要处理,于是立即处理事件
CFRunLoopWakeUp(_runLoopRef);
}else {
NSLog(@"RunLoop 正在处理事件");
//添加输入事件,当前正在处理一个事件,当前事件处理完成后,立即处理当前新输入的事件
CFRunLoopSourceSignal(_source);
}
});
}
//此输入源需要处理的后台事件
static void fire(void* info){
NSLog(@"我现在正在处理后台任务");
printf("%s",info);
}
输出结果如下:
2016-11-24 10:42:24.045 TestRunloop3[4683:238183] starting thread.......
2016-11-24 10:42:26.045 TestRunloop3[4683:238082] RunLoop 正在等待事件输入
2016-11-24 10:42:31.663 TestRunloop3[4683:238183] 我现在正在处理后台任务
hello
2016-11-24 10:42:31.663 TestRunloop3[4683:238183] end thread.......
- 例中可见我们创建一个自定义的输入源,绑定了一个函数,一个参数,并且用这个输入源,实现了线程间的通信。
- 大概讲一下:
a)```CFRunLoopRef _runLoopRef;```就不用说了,就是CF的runloop。
b)```CFRunLoopSourceContext _source_context;```注意到例中用了一个c函数```bzero(&_source_context, sizeof(_source_context));```来初始化。其实它本质是一个结构体如下:
typedef struct {
CFIndex version;
void * info;
const void (retain)(const void info);
void (release)(const void info);
CFStringRef (copyDescription)(const void info);
Boolean (equal)(const void *info1, const void info2);
CFHashCode (hash)(const void info);
void (schedule)(void info, CFRunLoopRef rl, CFRunLoopMode mode);
void (cancel)(void info, CFRunLoopRef rl, CFRunLoopMode mode);
void (perform)(void *info);
} CFRunLoopSourceContext;
- ```bzero(&_source_context, sizeof(_source_context));```所以这个函数其实就是把所有内容先置为0。
- 我们在这里绑定了两个参数一个是signal触发的函数,一个是函数的参数,至于其他参数的用途,可以看看苹果官方文档的说明如下:
>version
Version number of the structure. Must be 0.
info
An arbitrary pointer to program-defined data, which can be associated with the CFRunLoopSource at creation time. This pointer is passed to all the callbacks defined in the context.
retain
A retain callback for your program-defined info pointer. Can be NULL.
release
A release callback for your program-defined info pointer. Can be NULL.
copyDescription
A copy description callback for your program-defined info pointer. Can be NULL.
equal
An equality test callback for your program-defined info pointer. Can be NULL.
hash
A hash calculation callback for your program-defined info pointer. Can be NULL.
schedule
A scheduling callback for the run loop source. This callback is called when the source is added to a run loop mode. Can be NULL.
cancel
A cancel callback for the run loop source. This callback is called when the source is removed from a run loop mode. Can be NULL.
perform
A perform callback for the run loop source. This callback is called when the source has fired.
c)```CFRunLoopSourceRef _source;```这个是自定义输入源中最重要的一个参数。它用来连接runloop与CFRunLoopSourceContext中的一些配置项,**注意我们自定义的输入源,必须由我们手动来触发**。需要先```CFRunLoopSourceSignal(_source);```在看当前runloop是否在休眠中,来看是否需要调用```CFRunLoopWakeUp(_runLoopRef);```(一般都是要调用的)。
4) 定时源:
- 定时源在预设的时间点同步方式传递消息。定时器是线程通知自己做某事的一种方法。
- 尽管定时器可以产生基于时间的通知,但它并不是实时机制。和输入源一样,定时器也和 runloop 的特定模式相关。如果定时器所在的模式当前未被 runloop 监视,那么定时器将不会开始知道 runloop 运行在响应的模式下。类似的。如果定时器在 runloop 处理某一事件期间开始,定时器会一直等待直到下次 runloop 开始响应的处理程序。如果 runloop 不运行了,那么定时器也永远不启动。
- 配置定时源:
Cocoa 中可以使用以下 NSTimer 类方法来创建并调配一个定时器: