Controlling How NSThread and NSRunLoop Exit
http://shaheengandhi.com/controlling-thread-exit/
While most concurrency can be dealt with by using GCD dispatch queues, there are some things for which you will want to use a separate NSThread
. For instance, concurrent network programming remains mostly in this area. You may consider using the popular CocoaAsyncSocket
library, which abstracts away much of the complexity of socket programming on iOS. But, for the sake of this post, assume some work requires a separate thread, and we desire to cleanly start and stop the thread. That is, when we decide to start or stop the thread, we want to ensure it has been initialized or destroyed before moving on.
You can get the final version of the code example below at github.
Thread Setup
Remember that threads are an artefact of the operating system and not the objective-c runtime. That means all the nice stuff like an NSAutoreleasePool
and an NSRunLoop
need to be managed by the thread's top level code. Here is a code snippet of a thread's main method that sets up an autorelease pool as well as starts pumping NSRunLoop
.
- (void)start
{
if (_thread) {
return;
}
_thread = [[NSThread alloc] initWithTarget:self selector:@selector(threadProc:) object:nil];
}
- (void)threadProc:(id)ignored
{
@autoreleasepool {
// Startup code here
// Just spin in a tight loop running the runloop.
do {
[[NSRunLoop currentRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:1]]
} while (TRUE);
}
}
This code has many problems. Note that each run of the runloop has a timeout of 1 second. When the runloop has nothing to do for extended periods of time, the thread will still wake up every second and go through the while
loop's code, only to end up sitting in the runloop's wait condition. That burns CPU and battery. Also, this thread has no exit condition. Even if we want the thread to live until the end of the application's life, we probably want a way to shut it down cleanly. Here's an enumeration of the problems we want to fix:
- Unsure when the thread is ready for work
- Never goes to sleep
- No way to exit the thread cleanly
Solving all three problems at once is tricky. Fixing #2 means keeping the runloop asleep, preferrably waking only when there is work to be done (being notified by a runloop source). But, that makes it difficult to exit the thread in a timely manner.
Wait for Infinity
How can we make NSRunLoop
wait for infinity? The goal is to make sure that the thread goes to sleep. Looking at the documentation for runUntilDate:
, this is not the case:
If no input sources or timers are attached to the run loop, this method exits immediately; otherwise, it runs the receiver in the NSDefaultRunLoopMode by repeatedly invoking runMode:beforeDate: until the specified expiration date.
The second sentence means this code keeps spinning on the CPU, which is the exact opposite of our desired behavior. A better alternative isrunMode:beforeDate:
, for which the documentation reads:
If no input sources or timers are attached to the run loop, this method exits immediately and returns NO; otherwise, it returns after either the first input source is processed or limitDate is reached.
At least there's a chance the thread will sleep when using this method. However, the thread still runs in a continuous loop when there are no sources or timers. If you are only using a run loop to dispatch performSelector:
calls, you need to add a runloop source of your own to make the thread sleep. As a side effect, it would be effective to use this source to send work to the thread, but that is an exercise left to the reader.
One last thing: what value of NSDate
should be used? Any large value is fine, as waking the thread once a day is a large enough to keep the thread silent.+[NSDate distantFuture]
is a convenient factory for such a date.
static void DoNothingRunLoopCallback(void *info)
{
}
- (void)threadProc:(id)ignored
{
@autoreleasepool {
CFRunLoopSourceContext context = {0};
context.perform = DoNothingRunLoopCallback;
CFRunLoopSourceRef source = CFRunLoopSourceCreate(NULL, 0, &context);
CFRunLoopAddSource(CFRunLoopGetCurrent(), source, kCFRunLoopCommonModes);
do {
[[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode
beforeDate:[NSDate distantFuture]];
} while (TRUE);
CFRunLoopRemoveSource(CFRunLoopGetCurrent(), source, kCFRunLoopCommonModes);
CFRelease(source);
}
}
The exit condition
Now that the thread sleeps forever, how can we ensure a clean shutdown of the thread? It's entirely possible to use +[NSThread exit]
to kill the currently running thread. But, this does not clean up stack references to heap objects (like the runloop source that is created), drain the top level autorelease pool, nor allows the thread to flush any remaining work. Instead, we need to make the runloop stop sleeping in order to exit runMode:beforeDate:
, and we need a condition the thread can check in order to know it's time to shut down.
NSRunLoop
's conditions for exiting runMode:beforeDate:
are somewhat limited. Its return values being YES
(when the runloop processed an input source or if the timeout was reached) or NO
(when the runloop could not be started) aren't great. Given that the documentation states that NO
is returned only when there are no sources or timers, our code will never see NO
returned since we added an input source to keep the runloop from spinning!
Luckily, NSRunLoop
controls the same object that CFRunLoop
APIs do. The CoreFoundation alternative is to use CFRunLoopRunInMode
, which provides a more specific reason for the runloop's exit. Specifically,kCFRunLoopRunStopped
indicates the runloop was stopped byCFRunLoopStop
. This is also the reason that CFRunLoopRun
exits (other than having no sources or times, but that will not occur due to our fake source), so we don't need to bother with CFRunLoopRunInMode
, nor check a condition.
It is best to execute CFRunLoopStop
on the target thread itself. We can do this by using performSelector:onThread:withObject:waitUntilDone:
.
The new threadProc:
looks like this:
- (void)threadProc:(id)ignored
{
@autoreleasepool {
CFRunLoopSourceContext context = {0};
context.perform = DoNothingRunLoopCallback;
CFRunLoopSourceRef source = CFRunLoopSourceCreate(NULL, 0, &context);
CFRunLoopAddSource(CFRunLoopGetCurrent(), source, kCFRunLoopCommonModes);
// Keep processing events until the runloop is stopped.
CFRunLoopRun();
CFRunLoopRemoveSource(CFRunLoopGetCurrent(), source, kCFRunLoopCommonModes);
CFRelease(source);
}
}
We can use code like the following to exit the thread quickly from any thread, including the target thread itself:
- (void)stop
{
[self performSelector:@selector(_stop) onThread:_thread withObject:nil waitUntilDone:NO];
_thread = nil;
}
- (void)_stop
{
CFRunLoopStop(CFRunLoopGetCurrent());
}
Synchronizing thread startup and exit
Two more problems to solve: when starting the thread, can we ensure that it is ready? When shutting down a thread, can we ensure it is gone?
I would note that there are better threading patterns than attempting to ensure the state of the target thread. For example, a thread should be able to accept work, but simply not process it until it is ready. Resources outside of the thread's runloop should be minimal such that ensuring the thread is no longer executing should be above and beyond the desired knowledge of the thread's state.
It is tempting to simply add waitUntilDone:YES
to the performSelector
statement in order to wait until the target thread has exited, but that would only wait until the _stop
selector was invoked, and not wait for the thread's cleanup code to be run. In order to do that, we need to make a new assumption: the target thread is being shut down from another thread. It would be impossible for a thread to wait for itself to shut down.
In order for the target thread to signal to the control thread that it is done, a condition must be shared between them. NSCondition
provides convenient semantics for our purposes.
The thread management code is below. This pattern keeps a thread with no work asleep for long periods of time, while allowing for a fast and clean exit. It also allows for startup and shutdown to be synchronized.
- (void)start
{
if (_thread) {
return;
}
_thread = [[NSThread alloc] initWithTarget:self selector:@selector(threadProc:) object:nil];
// _condition was created in -init
[_condition lock];
[_thread start];
[_condition wait];
[_condition unlock];
}
- (void)stop
{
if (!_thread) {
return;
}
[_condition lock];
[self performSelector:@selector(_stop) onThread:_thread withObject:nil waitUntilDone:NO];
[_condition wait];
[_condition unlock];
_thread = nil;
}
- (void)threadProc:(id)object
{
@autoreleasepool {
CFRunLoopSourceContext context = {0};
context.perform = DoNothingRunLoopCallback;
CFRunLoopSourceRef source = CFRunLoopSourceCreate(NULL, 0, &context);
CFRunLoopAddSource(CFRunLoopGetCurrent(), source, kCFRunLoopCommonModes);
[_condition lock];
[_condition signal];
[_condition unlock];
// Keep processing events until the runloop is stopped.
CFRunLoopRun();
CFRunLoopRemoveSource(CFRunLoopGetCurrent(), source, kCFRunLoopCommonModes);
CFRelease(source);
[_condition lock];
[_condition signal];
[_condition unlock];
}
}
Ensuring Destruction of Thread Resources
There is still another issue with this code: when the thread has signaled its exit, the autorelease pool has not yet been drained. Without ensuring that the thread's memory resources have been released, the purpose of synchronizing the thread's exit becomes much less appealing.
There's a bit of a catch-22. NSCondition
makes no promise that it is free from using -autorelease
in its implementations of -lock
, -signal
, and-unlock
. That means there should be a valid NSAutoreleasePool
when using these APIs. We have two solutions available to us. We can either manually drain the autorelease pool, or use a different way to synchronize the thread's exit that waits until threadProc:
has exited. The first is somewhat messy. The second has two variants of its own.
Manual Autorelease
In order to use NSAutoreleasePool
directly, you must disable ARC.
Remember that -[NSAutoreleasePool drain]
is effectively the same as-[NSAutoreleasePool release]
and that the pool is no longer valid after draining it. So, manually draining an autorelease pool means creating another one to ensure the NSCondition
APIs have the right environment.
- (void)threadProc:(id)object
{
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
{
CFRunLoopSourceContext context = {0};
context.perform = DoNothingRunLoopCallback;
CFRunLoopSourceRef source = CFRunLoopSourceCreate(NULL, 0, &context);
CFRunLoopAddSource(CFRunLoopGetCurrent(), source, kCFRunLoopCommonModes);
[_condition lock];
[_condition signal];
[_condition unlock];
// Keep processing events until the runloop is stopped.
CFRunLoopRun();
CFRunLoopRemoveSource(CFRunLoopGetCurrent(), source, kCFRunLoopCommonModes);
CFRelease(source);
// Release all accumulated resources, but make sure NSCondition has the
// right environment.
[pool drain];
pool = [[NSAutoreleasePool alloc] init];
[_condition lock];
[_condition signal];
[_condition unlock];
}
[pool drain];
}
Using NSThreadWillExitNotification
NSThreadWillExitNotification
is a notification sent by NSThread
when the thread's main function has finished and the thread is about to finish execution. This must happen after threadProc:
, so this ensures the thread's top level autorelease pool has been drained. Since the notification fires on the exiting thread, NSCondition
is still used to synchronize the state of the thread.
- (void)stop
{
if (!_thread) {
return;
}
NSNotificationCenter *nc = [NSNotificationCenter defaultCenter];
[nc addObserver:self selector:@(_signal) name:NSThreadWillExitNotification object:_thread];
[_condition lock];
[self performSelector:@selector(_stop) onThread:_thread withObject:nil waitUntilDone:NO];
[_condition wait];
[_condition unlock];
[nc removeObserver:self name:NSThreadWillExitNotification object:_thread];
_thread = nil;
}
- (void)threadProc:(id)object
{
@autoreleasepool {
CFRunLoopSourceContext context = {0};
context.perform = DoNothingRunLoopCallback;
CFRunLoopSourceRef source = CFRunLoopSourceCreate(NULL, 0, &context);
CFRunLoopAddSource(CFRunLoopGetCurrent(), source, kCFRunLoopCommonModes);
[_condition lock];
[_condition signal];
[_condition unlock];
// Keep processing events until the runloop is stopped.
CFRunLoopRun();
CFRunLoopRemoveSource(CFRunLoopGetCurrent(), source, kCFRunLoopCommonModes);
CFRelease(source);
}
}
- (void)_signal
{
[_condition lock];
[_condition signal];
[_condition unlock];
}
Using pthreads
All of the above solutions have one slight problem: the thread hasn't quite exited when the control thread believes it has. The target thread is very close to being done, but that is not the same as done.
To ensure that, we must go outside the realm of NSThread
and use pthreads instead. pthread_join
guarantees the target thread has terminated. Using pthreads makes the code a bit more verbose, and some of the memory management must be done carefully. In particular, self
is retained when specifying it as an argument of NSThread
's initializer, but will not be retained when using it as an argument to pthread_create
. Note that we still need anNSThread
reference to useperformSelector:onThread:withObject:waitUntilDone:
, but there is no way to convert a pthread_t
to an NSThread
. Luckily,+[NSThread currentThread]
can obtain the correct object reference.
NSCondition
is still used to synchronize thread startup. Because it is not used for any other purpose, it is not necessary to lock the condition before starting the thread. However, to be consistent with previous code, we will follow the previous pattern of creating the thread in a suspended state and resuming it with the condition's lock held.
static void *ThreadProc(void *arg)
{
ThreadedComponent *component = (__bridge_transfer ThreadedComponent *)arg;
[component threadProc:nil];
return 0;
}
- (void)start
{
if (_thread) {
return;
}
if (pthread_create_suspended_np(&_pthread, NULL, &ThreadProc, (__bridge_retained void *)self) != 0) {
return;
}
// _condition was created in -init
[_condition lock];
mach_port_t mach_thread = pthread_mach_thread_np(_pthread);
thread_resume(mach_thread);
[_condition wait];
[_condition unlock];
}
- (void)stop
{
if (!_thread) {
return;
}
[self performSelector:@selector(_stop) onThread:_thread withObject:nil waitUntilDone:NO];
pthread_join(_pthread, NULL);
_thread = nil;
}
- (void)threadProc:(id)object
{
@autoreleasepool {
CFRunLoopSourceContext context = {0};
context.perform = DoNothingRunLoopCallback;
CFRunLoopSourceRef source = CFRunLoopSourceCreate(NULL, 0, &context);
CFRunLoopAddSource(CFRunLoopGetCurrent(), source, kCFRunLoopCommonModes);
// Obtain the current NSThread before signaling startup is complete.
_thread = [NSThread currentThread];
[_condition lock];
[_condition signal];
[_condition unlock];
// Keep processing events until the runloop is stopped.
CFRunLoopRun();
CFRunLoopRemoveSource(CFRunLoopGetCurrent(), source, kCFRunLoopCommonModes);
CFRelease(source);
}
}
Controlling How NSThread and NSRunLoop Exit的更多相关文章
- NSThread 、NSRunLoop 和 Dispatch Queue
iOS多线程编程中,NSOperation和NSOperationQueue无疑是最常用的,它们能满足绝大部分情况下的线程操作.但在完成一些特殊的任务时,我们还是要使用的NSThread和NSRun ...
- NSTimer、 NSTask、 NSThread 和 NSRunloop 之间的区别
NSTimer是一个计时器对象,方法调用在对未来的选择对象. NSThread是一个线程类. 也就是创建一个线程. NSTask类是一个过程,一种方式运行程序从您的其他程序. NSOperation是 ...
- NSThread 子线程 Cocoa NSOperation GCD(Grand Central Dispatch) 多线程
单词:thread 英 θred:n 线.思路.vt 穿过.vi 穿透过 一. 进程.线程 进程:正在进行中的程序被称为进程,负责程序运行的内存分配,每一个进程都有自己独立的虚拟内存空间 线程: ...
- iOS-----多线程之NSThread
多线程 iOS平台提供了非常优秀的多线程支持,程序可以通过非常简单的方式来启动多线程,iOS平台不仅提供了NSThread类来创建多线程,还提供了GCD方式来简化多线程编程,提供了NSOperatio ...
- iOS 如何保持线程一直在运转(二)
一.接着上一篇通过NSThread可以方便的创建一个线程,并且启动线程的Runloop,在线程体中执行一个while循环 然后我们就可以方便得利用这个线程了 - (void)threadRun:(NS ...
- 深入研究 Runloop 与线程保活
深入研究 Runloop 与线程保活 在讨论 runloop 相关的文章,以及分析 AFNetworking(2.x) 源码的文章中,我们经常会看到关于利用 runloop 进行线程保活的分析,但如果 ...
- Runloop理解
看了一堂公开课,自己小结一下: Runloop: 内部有三个东东:(Source, Timer, Observer) 作用/本质:1.死循环 (为app 保活): 2.监听处理事件 Timer 理解: ...
- 第2月第1天 GCDAsyncSocket dispatch_source_set_event_handler
一.GCDAsyncSocket的核心就是dispatch_source_set_event_handler 1.accpet回调 accept4Source = dispatch_source_cr ...
- 【引】objective-c,6:Autorelease Pool
参考博客: http://blog.leichunfeng.com/blog/2015/05/31/objective-c-autorelease-pool-implementation-princi ...
随机推荐
- Shell 脚本模拟 milter 实现黑白名单及关键词过滤
程序执行流程:1. 开始接受邮件.2. 检查发件人是否在黑名单内,如果是拒绝接受;否则继续3. 检查发件人是否在白名单内,如果是接收邮件;否则继续4. 对邮件进行关键字过滤,如果邮件中包含被过滤的关键 ...
- JS HTML 单引号与双引号
JS中,单引号和双引号其实没啥区别,看你自己习惯了. 但若双引号中再使用双引号,我们可采取"外双内单"或者"外单内双"的格式,当然如果需要的是双引号本身,则只能 ...
- 一道在知乎很火的 Java 题——如何输出 ab【转】
这是一个源自知乎的话题,原贴链接:一道百度的面试题,有大神会嘛? 虽然我不是大神,但我也点进去看了一下,思考了一会之后有了一些思路,然后去看其它人的答案的时候果然全都已经被各路大神们先想到并贴出来了, ...
- codevs 1282 约瑟夫问题(线段树)
#include<iostream> #include<cstdio> #include<cstring> #define maxn 30010 using nam ...
- JSON和JSONP区别
JSON(JavaScript Object Notation)和JSONP(JSON with Padding) JSON是一种数据交换格式,JSONP是一种跨域数据交互协议 JSONP利用scri ...
- 关于svn获取获取文件时 Unable to connect to a repository at URL"https://..."执行上下文错误:参数错误
错误提示: 下面的六种解决方案都未能解决: 1.不提示输入用户名和密码,不管重装多少次都一样. 2.TortoiseSVN的setting->Saved Data->Authenticat ...
- C# Wpf集合双向绑定
说明: msdn中 ObservableCollection<T> 类 表示一个动态数据集合,在添加项.移除项或刷新整个列表时,此集合将提供通知. 在许多情况下,所使用的数据是对 ...
- webconfig的设置节点几个说明
有助于深入理解webconfig <?xml version="1.0" encoding="utf-8" ?> <configuration ...
- 七.生成n位随机字符串
--1.借助newid() go --创建视图(因为在函数中无法直接使用newid()) create view vnewid as select newid() N'MacoId'; go --创建 ...
- [转] 关于UIView
[转载] 原文地址 :http://blog.csdn.net/itianyi/article/details/8982518 UIView是开发中使用得最多的控件了,深入的理解很有必要. UIVie ...