苹果的Grand Central Dispatch (GCD)功能很好，但仅适用于iOS 4.0或更高版本。 苹果的文档说：“[一个]串行操作队列并没有像 Grand Central Dispatch 中的串行派发队列一样提供完全相同的行为”(因为队列不是FIFO，而是由依赖和优先级确定顺序)。
如何以支持GCD发布之前的iOS版本的方式实现与GCD串行派发队列相同的效果呢？或者换句话说，iOS应用程序中处理简单的后台处理(执行Web服务请求等)的推荐方法是什么，这些应用程序希望支持低于4.0版本的iOS？
#import <Foundation/Foundation.h>
@interface PseudoTask : NSObject
{
id target_;
SEL selector_;
id queue_;
}
@property (nonatomic, readonly) id target;
- (id)initWithTarget:(id)target selector:(SEL)selector queue:(id)queue;
- (void)exec;
@end
@implementation PseudoTask
@synthesize target=target_;
- (id)initWithTarget:(id)target selector:(SEL)selector queue:(id)queue;
{
self = [super init];
if (self) {
target_ = [target retain];
selector_ = selector;
queue_ = [queue retain];
}
return self;
}
- (void)exec
{
[target_ performSelector:selector_];
}
- (void)dealloc
{
[target_ release];
[queue_ release];
}
@end
@interface PseudoSerialQueue : NSObject
{
NSCondition *condition_;
NSMutableArray *array_;
NSThread *thread_;
}
- (void)addTask:(id)target selector:(SEL)selector;
@end
@implementation PseudoSerialQueue
- (id)init
{
self = [super init];
if (self) {
array_ = [[NSMutableArray alloc] init];
condition_ = [[NSCondition alloc] init];
thread_ = [[NSThread alloc]
initWithTarget:self selector:@selector(execQueue) object:nil];
[thread_ start];
}
return self;
}
- (void)addTask:(id)target selector:(SEL)selector
{
[condition_ lock];
PseudoTask *task = [[PseudoTask alloc]
initWithTarget:target selector:selector queue:self];
[array_ addObject:task];
[condition_ signal];
[condition_ unlock];
}
- (void)quit
{
[self addTask:nil selector:nil];
}
- (void)execQueue
{
for (;;) {
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
[condition_ lock];
while (array_.count == 0)
[condition_ wait];
PseudoTask *task = [array_ objectAtIndex:0];
[array_ removeObjectAtIndex:0];
[condition_ unlock];
if (!task.target) {
[pool drain];
break;
}
[task exec];
[task release];
[pool drain];
}
}
- (void)dealloc
{
[array_ release];
[condition_ release];
}
@end
使用方法：
PseudoSerialQueue *q = [[[PseudoSerialQueue alloc] init] autorelease];
[q addTask:self selector:@selector(test0)];
[q addTask:self selector:@selector(test1)];
[q addTask:self selector:@selector(test2)];
[q quit];
- (void)startRunLoop:(id)someObject
{
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
[[NSRunLoop currentRunLoop] run];
[pool release];
}
...
NSThread *serialDispatchThread = [[NSThread alloc]
initWithTarget:self
selector:@selector(startRunLoop:)
object:nil];
[serialDispatchThread start];
[object
performSelector:@selector(whatever:)
onThread:serialDispatchThread
withObject:someArgument
waitUntilDone:NO];
NSOperationQueue进行模拟，然后将任务数量设置为一。
编辑
-- 哎呀，我应该仔细阅读的。下面是fifo解决方案：NSOperationQueue 的段落中。但与串行调度队列相反，它似乎表明不能保证任务先进先出执行。 - jrdiokoNSOperationQueue 的子类，确保其添加的所有操作都没有任何依赖关系... 实际上，除非你明确地自己设置它们，否则你 已经 确保它是 FIFO。 - Dave DeLong在NSOperationQueue的文档中，有些细节被遗漏了，导致实现起来似乎很简单，但实际上并非如此。
将最大并发操作数设置为1只有在从同一线程向队列添加NSOperations时才能保证串行执行。
我使用另一种选项，因为它能正常工作。
可以从不同的线程添加NSOperations，但使用NSCondition来管理排队。startOperations方法可以（而且应该）使用performSelectorOnBackgroundThread进行调用，这样就不会使用锁阻塞主线程。
startOperations方法代表一个由一个或多个NSOperations组成的单个作业。
- (void)startOperations
{
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
[[AppDelegate condition] lock];
while (![[[AppDelegate queue] operations] count] <= 0)
{
[[AppDelegate condition] wait];
}
NSOperation *newOperation = [alloc, init]....;
[[AppDelegate queue] addOperation:newOperation];
[[AppDelegate queue] waitUntilAllOperationsAreFinished]; // Don't forget this!
NSOperation *newOperation1 = [alloc, init]....;
[[AppDelegate queue] addOperation:newOperation1];
[[AppDelegate queue] waitUntilAllOperationsAreFinished]; // Don't forget this!
NSOperation *newOperation2 = [alloc, init]....;
[[AppDelegate queue] addOperation:newOperation2];
[[AppDelegate queue] waitUntilAllOperationsAreFinished]; // Don't forget this!
// Add whatever number operations you need for this single job
[[AppDelegate queue] signal];
[[AppDelegate queue] unlock];
[NotifyDelegate orWhatever]
[pool drain];
}
如果处理过程本来就在后台进行，那么你真的需要它严格按顺序吗？如果需要，你可以通过设置依赖关系来实现相同的效果，使得1依赖于0，2依赖于1，3依赖于2等等。操作队列将被强制按顺序处理它们。将最大并发操作数设置为1，队列也保证是串行的。
NSThread层面，但看起来应该可以工作（还没有尝试过）。不过似乎仍然应该有一种更简单的方法来做到这一点... - jrdioko