深入理解Runloop

       
字数统计: 3.6k字   |   阅读时长: 16min

最近在研究检测页面卡顿的问题，发现基本上都是基于Runloop的，所以打算把Runloop再好好复习一遍，于是就把学习的过程记录一下。

在OSX/iOS 系统中，提供了两个对象：NSRunLoop（线程不安全） 和 CFRunLoopRef（线程安全）。但是NSRunloop是闭源的，我们无法直接查看到内部实现，但是CFRunLoopRef是开源的，CFRunLoopRef 在 CoreFoundation 框架内，它提供了纯 C 函数的 API，接下来我们就分析一下CFRunLoopRef的内部实现。目前最新的版本是 CF-855.17.

在开发中，我们可以通过两种方式来获取线程，

NSThread：

  • [NSThread mainThread]获取主线程

  • [NSThread currentThread]获取当前线程

pthread：

  • pthread_main_np() 获取主线程

  • pthread_self() 获取当前线程

CFRunLoop 是基于 pthread 来管理的。

可以看出这两者是一一对应的，但是没有找到这两者的转换方式. 不过我们可以用pthread_t pthread_from_mach_thread_np(mach_port_t)进行pthread_t 和mach_port_t 两者的转换。 task_threads 这个函数可以返回任务中的线程列表。
mach_msg_type_number_t count;
thread_act_array_t list;
task_threads(mach_task_self(), &list, &count);

我们不能直接创建RunLoop,我们也可以通过两种方式来获取，

NSRunLoop：

  • [NSRunLoop mainRunLoop];获取主runloop

  • [NSRunLoop currentRunLoop];获取当前runloop

CFRunLoopRef：

  • CFRunLoopGetMain()获取主runloop

  • CFRunLoopGetCurrent()获取当前runloop

我们先来看一下CFRunLoopGetMain函数的实现方式：

1
2
3
4
5
6
CFRunLoopRef CFRunLoopGetMain(void) {
    CHECK_FOR_FORK();
    static CFRunLoopRef __main = NULL; // no retain needed
    if (!__main) __main = _CFRunLoopGet0(pthread_main_thread_np()); // no CAS needed
    return __main;
}

CFRunLoopGetCurrent函数的实现方式：

1
2
3
4
5
6
CFRunLoopRef CFRunLoopGetCurrent(void) {
    CHECK_FOR_FORK();
    CFRunLoopRef rl = (CFRunLoopRef)_CFGetTSD(__CFTSDKeyRunLoop);
    if (rl) return rl;
    return _CFRunLoopGet0(pthread_self());
}

看到这两个函数都调用了_CFRunLoopGet0这个函数，可见这个函数才是核心，看下这个函数的实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
// key是pthread_t， value是CFRunLoopRef
static CFMutableDictionaryRef __CFRunLoops = NULL;
static CFSpinLock_t loopsLock = CFSpinLockInit;

// 获取一个pthread对应的runloop
CFRunLoopRef _CFRunLoopGet0(pthread_t t) {
    if (pthread_equal(t, kNilPthreadT)) {
		t = pthread_main_thread_np();
    }
    __CFSpinLock(&loopsLock);
    if (!__CFRunLoops) {
        __CFSpinUnlock(&loopsLock);
    // 创建一个字典，key是pthread，value是runloop
	CFMutableDictionaryRef dict = CFDictionaryCreateMutable(kCFAllocatorSystemDefault, 0, NULL, &kCFTypeDictionaryValueCallBacks);
	// 创建一个主线程的runloop
	CFRunLoopRef mainLoop = __CFRunLoopCreate(pthread_main_thread_np());
	CFDictionarySetValue(dict, pthreadPointer(pthread_main_thread_np()), mainLoop);
	if (!OSAtomicCompareAndSwapPtrBarrier(NULL, dict, (void * volatile *)&__CFRunLoops)) {
	    CFRelease(dict);
	}
	CFRelease(mainLoop);
        __CFSpinLock(&loopsLock);
    }
    // 通过pthread直接取runloop
    CFRunLoopRef loop = (CFRunLoopRef)CFDictionaryGetValue(__CFRunLoops, pthreadPointer(t));
    __CFSpinUnlock(&loopsLock);
    if (!loop) {
	CFRunLoopRef newLoop = __CFRunLoopCreate(t);
        __CFSpinLock(&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
        __CFSpinUnlock(&loopsLock);
	CFRelease(newLoop);
    }
    if (pthread_equal(t, pthread_self())) {
    // 注册一个回调，当线程销毁时，顺便也销毁其对应的 RunLoop。
        _CFSetTSD(__CFTSDKeyRunLoop, (void *)loop, NULL);
        if (0 == _CFGetTSD(__CFTSDKeyRunLoopCntr)) {
            _CFSetTSD(__CFTSDKeyRunLoopCntr, (void *)(PTHREAD_DESTRUCTOR_ITERATIONS-1), (void (*)(void *))__CFFinalizeRunLoop);
        }
    }
    return loop;
}

从上面的代码可以看出，线程和RunLoop之间是一一对应的，其关系是保存在一个全局的 Dictionary 里。线程刚创建时并没有 RunLoop，如果你不主动获取，那它一直都不会有。RunLoop 的创建是发生在第一次获取时，RunLoop 的销毁是发生在线程结束时。你只能在一个线程的内部获取其 RunLoop（主线程除外）。

接下来我们可以在CFRunLoop.h文件中看到几个对外提供的接口：

1
2
3
4
5
6
7
8
9
typedef CFStringRef CFRunLoopMode CF_EXTENSIBLE_STRING_ENUM;

typedef struct CF_BRIDGED_MUTABLE_TYPE(id) __CFRunLoop * CFRunLoopRef;

typedef struct CF_BRIDGED_MUTABLE_TYPE(id) __CFRunLoopSource * CFRunLoopSourceRef;

typedef struct CF_BRIDGED_MUTABLE_TYPE(id) __CFRunLoopObserver * CFRunLoopObserverRef;

typedef struct CF_BRIDGED_MUTABLE_TYPE(NSTimer) __CFRunLoopTimer * CFRunLoopTimerRef;

在CFRunLoop.c文件看到了还有__CFRunLoopMode结构体，

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
struct __CFRunLoopMode {
    CFRuntimeBase _base;
    pthread_mutex_t _lock;	/* must have the run loop locked before locking this */
    CFStringRef _name;
    Boolean _stopped;
    char _padding[3];
    CFMutableSetRef _sources0; // 非基于Port的 ，用于用户主动触发事件
    CFMutableSetRef _sources1; // 包含了一个 mach_port，被用于通过内核和其他线程相互发送消息,能主动唤醒 RunLoop 的线程。
    CFMutableArrayRef _observers;
    CFMutableArrayRef _timers;
    CFMutableDictionaryRef _portToV1SourceMap;
    __CFPortSet _portSet;
    CFIndex _observerMask;
#if USE_DISPATCH_SOURCE_FOR_TIMERS
    dispatch_source_t _timerSource;
    dispatch_queue_t _queue;
    Boolean _timerFired; // set to true by the source when a timer has fired
    Boolean _dispatchTimerArmed;
#endif
#if USE_MK_TIMER_TOO
    mach_port_t _timerPort;
    Boolean _mkTimerArmed;
#endif
#if DEPLOYMENT_TARGET_WINDOWS
    DWORD _msgQMask;
    void (*_msgPump)(void);
#endif
    uint64_t _timerSoftDeadline; /* TSR */
    uint64_t _timerHardDeadline; /* TSR */
};
1
2
3
4
5
6
7
8
9
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
    kCFRunLoopAllActivities = 0x0FFFFFFFU
};
1
2
3
4
5
6
// 指定一个Mode启动，允许设置超时时间   
SInt32 CFRunLoopRunInMode(CFStringRef modeName, CFTimeInterval seconds, Boolean returnAfterSourceHandled) {     /* DOES CALLOUT */
    CHECK_FOR_FORK();
    return CFRunLoopRunSpecific(CFRunLoopGetCurrent(), modeName, seconds, returnAfterSourceHandled);
}

1
2
3
4
5
6
7
8
// 使用kCFRunLoopDefaultMode启动
void CFRunLoopRun(void) {	/* DOES CALLOUT */
    int32_t result;
    do {
        result = CFRunLoopRunSpecific(CFRunLoopGetCurrent(), kCFRunLoopDefaultMode, 1.0e10, false);
        CHECK_FOR_FORK();
    } while (kCFRunLoopRunStopped != result && kCFRunLoopRunFinished != result);
}
实际上 RunLoop 就是这样一个函数，其内部是一个 do-while 循环。当你调用 CFRunLoopRun() 时，线程就会一直停留在这个循环里；直到超时或被手动停止，该函数才会返回.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
// runloop的实现
SInt32 CFRunLoopRunSpecific(CFRunLoopRef rl, CFStringRef modeName, CFTimeInterval seconds, Boolean returnAfterSourceHandled) {     /* DOES CALLOUT */
    CHECK_FOR_FORK();
    if (__CFRunLoopIsDeallocating(rl)) return kCFRunLoopRunFinished;
    __CFRunLoopLock(rl);
    // 根据modeName找到当前对应的mode
    CFRunLoopModeRef currentMode = __CFRunLoopFindMode(rl, modeName, false);
    
    // 如果currentMode里没有source/timer/observer, 直接返回kCFRunLoopRunFinished，如果有则开始处理source
    if (NULL == currentMode || __CFRunLoopModeIsEmpty(rl, currentMode, rl->_currentMode)) {
	Boolean did = false;
	if (currentMode) __CFRunLoopModeUnlock(currentMode);
	__CFRunLoopUnlock(rl);
	return did ? kCFRunLoopRunHandledSource : kCFRunLoopRunFinished;
    }
    volatile _per_run_data *previousPerRun = __CFRunLoopPushPerRunData(rl);
    CFRunLoopModeRef previousMode = rl->_currentMode;
    rl->_currentMode = currentMode;
    int32_t result = kCFRunLoopRunFinished;

	if (currentMode->_observerMask & kCFRunLoopEntry ) 
	// 通知 Observers: 即将进入runloop。
	__CFRunLoopDoObservers(rl, currentMode, kCFRunLoopEntry);
	result = __CFRunLoopRun(rl, currentMode, seconds, returnAfterSourceHandled, previousMode);
		// 通知 Observers: 即将退出runloop。
	if (currentMode->_observerMask & kCFRunLoopExit ) __CFRunLoopDoObservers(rl, currentMode, kCFRunLoopExit);

        __CFRunLoopModeUnlock(currentMode);
        __CFRunLoopPopPerRunData(rl, previousPerRun);
	rl->_currentMode = previousMode;
    __CFRunLoopUnlock(rl);
    return result;
}

通过代码我们可以看出：一个 RunLoop 包含多个 Mode，每个 Mode 又包含多个 Source/Timer/Observer。每次调用CFRunLoopRunInMode时，只能指定其中一个 Mode，这个Mode被称作 CurrentMode。如果需要切换 Mode，只能退出 Loop，再重新指定一个 Mode 进入。这样做主要是为了分隔开不同组的 Source/Timer/Observer，让其互不影响。

Runloop内部逻辑

我们给当前runloop添加一个观察者：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
static void callback(CFRunLoopObserverRef observer, CFRunLoopActivity activity,void *info) {
	switch (activity) {
		case kCFRunLoopEntry:
			NSLog(@"即将进入runloop");
			break;
		case kCFRunLoopBeforeTimers:
			NSLog(@"即将处理 Timer");
			break;
		case kCFRunLoopBeforeSources:
			NSLog(@"即将处理 Sources");
			break;
		case kCFRunLoopBeforeWaiting:
			NSLog(@"即将进入休眠");
			break;
		case kCFRunLoopAfterWaiting:
			NSLog(@"从休眠中唤醒loop");
			break;
		case kCFRunLoopExit:
			NSLog(@"即将退出runloop");
			break;
			
		default:
			break;
	}
}

	CFRunLoopRef runLoop = CFRunLoopGetCurrent();
	CFRunLoopObserverContext context = { 0,
										 (__bridge void *)(self),
		                                 &CFRetain,
		                                 &CFRelease,
		                                 NULL };
	CFOptionFlags activitys = (kCFRunLoopBeforeWaiting | kCFRunLoopExit);
	
	// CFRunLoopObserverCreate(<#CFAllocatorRef allocator#>, <#CFOptionFlags activities#>, <#Boolean repeats#>, <#CFIndex order#>, <#CFRunLoopObserverCallBack callout#>, <#CFRunLoopObserverContext *context#>)
	/**
	 第一个参数：（<#CFAllocatorRef allocator#>）分配存储空间
	 第二个参数：（<#CFOptionFlags activities#>）要监听的状态（kCFRunLoopAllActivities）所有的状态
	 第三个参数：（<#Boolean repeats#>）是否持续监听
	 第四个参数：（<#CFIndex order#>）优先级
	 第五个参数：回调
	 */
	CFRunLoopObserverRef observer = CFRunLoopObserverCreate(CFAllocatorGetDefault(), activitys, YES, INT_MAX, &callback, &context);

	CFRunLoopAddObserver(runLoop, observer, kCFRunLoopCommonModes);
	
	CFRelease(observer);

我们可以自己写一个timer试验一下，发现如下打印：

1
2
3
4
5
6
7
8
/**
	2017-06-12 20:35:15.779 CodeTest[43168:5 050565] 从休眠中唤醒loop
    2017-06-12 20:35:15.780 CodeTest[43168:5050565] <__NSCFTimer: 0x600000176380>
    2017-06-12 20:35:15.780 CodeTest[43168:5050565] 即将处理 Timer
    2017-06-12 20:35:15.780 CodeTest[43168:5050565] 即将处理 Sources
    2017-06-12 20:35:15.780 CodeTest[43168:5050565] 即将进入休眠
 */

执行逻辑跟图示一样

Runloop线程保活

从苹果的官方文档看，我们可以看到runloop开启有这四种方式：

1
- (void)run;

我们先来看下这个方法，它会开启一个永驻的runloop，来处理Input Source，内部会循环调用runMode：beforeDate，并且运行在NSDefaultRunLoopMode这个模式下，即使用void CFRunLoopStop(CFRunLoopRef rl)也无法停止runloop的运行，除非能移除这个runloop上的所有事件源，包括timer和source，不然这个子线程就无法停止，只能永久运行下去。

但是并不建议我们使用这个方法来开启，如果我们想要停止runloop。我们可以采用这种方式，

1
2
3
BOOL shouldKeepRunning = YES; // global
NSRunLoop *theRL = [NSRunLoop currentRunLoop];
while (shouldKeepRunning && [theRL runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]]);

当条件shouldKeepRunning设置为NO的时候，我们就可以退出runloop

1
- (void)runUntilDate:(NSDate *)limitDate;

这个方法我们可以设置一个超时时间，如果没有检测到timer和source输入源，runloop则立刻退出，否则当到达超时时间的时候才会退出，这个方法也是运行在NSDefaultRunLoopMode模式下的，需要注意的是void CFRunLoopStop(CFRunLoopRef rl)也无法停止runloop的运行

1
2
3
4
5
6
BOOL shouldKeepRunning = YES; // global
NSRunLoop *theRL = [NSRunLoop currentRunLoop];
while (!shouldKeepRunning) {
  [theRL runUntilDate:[NSDate dateWithTimeIntervalSinceNow:5]];
  // do somthing
}

这个方法无非就是每隔5秒退出一次，然后判断自己需要做的事并可以设置shouldKeepRunning是否需要设置为NO

1
- (BOOL)runMode:(NSRunLoopMode)mode beforeDate:(NSDate *)limitDate;

这个方法比上面的方法多了一个mode参数，这种方式是可以使用void CFRunLoopStop(CFRunLoopRef rl)停止runloop运行的。但是需要注意的是，这种方法会导致runloop退出，我们看如下代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
dispatch_async(dispatch_get_global_queue(0, 0), ^{
	NSLog(@"线程开始");
	//获取到当前线程
	self.thread = [NSThread currentThread];
	
	NSRunLoop *runloop = [NSRunLoop currentRunLoop];
	
	//[runloop addPort:[NSMachPort port] forMode:NSDefaultRunLoopMode];
	
	[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]);
}

我们会发现打印 :
2017-06-20 10:14:45.653 CodeTest[47702:5665253] 线程开始
2017-06-20 10:14:45.654 CodeTest[47702:5665253] 线程结束

也就是说根本不会执行recieveMsg这个方法，因为这个线程执行完，没有检测到输入源就会立刻退出runloop。需要注意的是，如果我们在- (void)performSelector:(SEL)aSelector onThread:(NSThread *)thr withObject:(nullable id)arg waitUntilDone:(BOOL)wait; 这个方法中把wait设置成了YES，则如果线程退出了话，就会crash

但是如果我们把[runloop addPort:[NSMachPort port] forMode:NSDefaultRunLoopMode];这行代码打开的话，会出现如下打印：

2017-06-20 10:27:02.673 CodeTest[47749:5678254] 线程开始
2017-06-20 10:27:04.867 CodeTest[47749:5678254] 收到消息了，在这个线程：<NSThread: 0x608000069fc0>{number = 3, name = (null)}
2017-06-20 10:27:04.867 CodeTest[47749:5678254] 线程结束

那么为什么添加一个端口就可以让线程不退出呢？ 添加一个端口监听这个端口的事件，这个就是我们之前所说的source1，保证runloop有输入源，也就是保证runloop不会退出，这也是一种线程间的通信方式-基于端口的通信。

1
2
3
4
5
6
7
8
CFRunLoopSourceRef rls = __CFRunLoopModeFindSourceForMachPort(rl, rlm, livePort);
   if (rls) {
	mach_msg_header_t *reply = NULL;
	sourceHandledThisLoop = __CFRunLoopDoSource1(rl, rlm, rls, msg, msg->msgh_size, &reply) || sourceHandledThisLoop;
if (NULL != reply) {
   	(void)mach_msg(reply, MACH_SEND_MSG, reply->msgh_size, 0, MACH_PORT_NULL, 0, MACH_PORT_NULL);
   CFAllocatorDeallocate(kCFAllocatorSystemDefault, reply);
}

如果一个 Source1 (基于port) 发出事件了，就处理这个事件，这就是为什么有port能线程保活的原因。

线程通信

线程间的通信，实际上是各种输入源，触发runloop去处理对应的事件，输入源会异步的发送消息给你的线程。事件来源取决于输入源的种类：基于端口的输入源和自定义输入源。

  • 基于端口的输入源监听程序相应的端口。
  • 自定义输入源则监听自定义的事件源。

两类输入源的区别在于：基于端口的输入源由内核自动发送，而自定义的则需要人工从其他线程发送。

基于端口的输入源:
在runloop中，被定义名为souce1。Cocoa和CoreFoundation内置支持使用端口相关的对象和函数来创建的基于端口的源。在Cocoa里面你从来不需要直接创建输入源。你只要简单的创建端口对象，并使用NSPort的方法把该端口添加到runloop。端口对象会自己处理创建和配置输入源。

Cocoa里用来线程间传值的是NSMachPort，它的父类是NSPort。

1
2
3
NSPort *port = [NSPort port];
NSMachPort *machPort = [NSMachPort port];
NSPort *machPort_port = [NSMachPort port];

然后发现怎么创建都是返回 NSMachPort对象。。。。。

利用NSMachPort来实现线程通信的🌰

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
	NSPort *mainPort = [NSPort port];
	NSPort *threadPort = [NSPort port];
	
	threadPort.delegate = self;
	
	//给主线程runloop加一个端口
	[[NSRunLoop mainRunLoop] addPort:mainPort forMode:NSDefaultRunLoopMode];
	
	dispatch_async(dispatch_get_global_queue(0, 0), ^{
		//给子线程runloop加一个端口
		[[NSRunLoop currentRunLoop] addPort:threadPort forMode:NSDefaultRunLoopMode];
		[[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]];
	});
	
	NSString *str = @"hello world！";
	NSData *data = [str 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]];
		/**
		 @param limitDate 限制时间
		 @param msgID 信息标识
		 @param components 消息组件
		 @param receivePort 接受端口
		 @param headerSpaceReserved 为头部预留的字节数
		 */
		[threadPort sendBeforeDate:[NSDate date] msgid:1000 components:array from:mainPort reserved:0];
	});

- (void)handlePortMessage:(id)message {
	NSLog(@"收到消息了，线程为：%@",[NSThread currentThread]);
	//只能用KVC的方式取值
	NSArray *array = [message valueForKeyPath:@"components"];
	NSData *data =  array[1];
	NSString *str = [[NSString alloc]initWithData:data encoding:NSUTF8StringEncoding];
	NSLog(@"%@",str);
}

出现如下打印：

2017-06-20 12:05:34.441 CodeTest[48264:5786736] 收到消息了，线程为:<NSThread: 0x608000261800>{number = 3, name = (null)}

2017-06-20 12:05:34.441 CodeTest[48264:5786736] hello world！

说明我们从主线程往子线程发送了消息

需要注意的是，components这个传参数组里面只能装两种类型的数据，一种是NSPort的子类，一种是NSData的子类。

自定义输入源，自定义输入源必须是使用CoreFoundation里面的CGRunLoopSourceRef类型相关的函数来创建。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
CFRunLoopRef _runLoopRef;
CFRunLoopSourceRef _source;
CFRunLoopSourceContext _context;

dispatch_async(dispatch_get_global_queue(0, 0), ^{
		
		NSLog(@"starting thread.......");
		_runLoopRef = CFRunLoopGetCurrent();
		//初始化_context,把所有内容先置为0
		bzero(&_context, sizeof(_context));
		//这里创建了一个基于事件的源，绑定了一个函数
		_context.perform = fire;
		//参数
		_context.info = "hello";
		
		_source = CFRunLoopSourceCreate(NULL, 0, &_context);
		
		CFRunLoopAddSource(_runLoopRef, _source, kCFRunLoopDefaultMode);
		
		CFRunLoopRunInMode(kCFRunLoopDefaultMode, 10, YES);
		
		NSLog(@"end thread.......");
	});
	
	dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5 * 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(@"我现在正在处理后台任务");
	char *str = info;
	NSLog(@"%s",str);
}

出现如下打印：

2017-06-20 12:27:39.164 CodeTest[48418:5812271] starting thread…….

2017-06-20 12:27:44.165 CodeTest[48418:5812163] RunLoop 正在等待事件输入

2017-06-20 12:27:44.165 CodeTest[48418:5812271] 我现在正在处理后台任务

2017-06-20 12:27:44.165 CodeTest[48418:5812271] hello

2017-06-20 12:27:44.165 CodeTest[48418:5812271] end thread…….

最后，学习还请看大神的文章

本文作者： Aeron_Xie
最后更新： 2023年03月25日 22:39:55
本文链接： http://aeronxie.github.io/post/cf8f80df.html
版权声明： 本作品采用 CC BY-NC-SA 4.0 许可协议进行许可，转载请注明出处！

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

    			  jsonContent:
				meta: false
				pages: false
				posts:
				  title: true
				  date: true
				  path: true
				  text: false
				  raw: false
				  content: false
				  slug: false
				  updated: false
				  comments: false
				  link: false
				  permalink: false
				  excerpt: false
				  categories: false
				  tags: true


喜欢各种新鲜事物，会 Android \ Swift \ Python \ Java \ C \ Javascript \ Objective-C 单词的拼写~~~~