Эквивалент очереди последовательной отправки GCD в iOS 3.x

Похоже, что люди приложат немало усилий, чтобы переписать NSRunloop. Согласно документации NSRunloop :

- (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];

Согласно разделу Руководства по программированию потоков в циклах выполнения < / а>:

Как насчет этой PseudoSerialQueue? Это минимальная реализация, такая как Dispatch Serial Queue.

#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];

вы можете смоделировать это, используя NSOperationQueue, а затем просто установите счетчик задач равным единице.

ИЗМЕНИТЬ

- ой, читал внимательнее. Решение FIFO следующее:

Я не могу придумать, как бы большинство разработчиков iOS использовали в вашей ситуации.

Я не боюсь писать многопоточные программы, поэтому вот одно решение:

• создать рабочую очередь FIFO, которая:
• • supports locking
• • holds one NSOperationQueue
• • holds an NSOperation subclass, designed to pull workers from the fifo queue in its implementation of main. only one may exist at a time.
• • holds an NSArray of workers to be run (defining a worker is up to you - is it an NSInvocation, class, operation, ...)

подкласс NSOperation извлекает рабочих из очереди рабочих файлов fifo до тех пор, пока очередь рабочих файлов fifo не будет исчерпана.

когда в рабочей очереди fifo есть рабочие и нет активной дочерней операции, она создает дочернюю операцию, добавляет ее в свою очередь операций.

Есть несколько подводных камней, если вам неудобно писать многопоточные программы - по этой причине это решение не идеально для всех, но это решение не займет много времени, если вы уже освоили все необходимые технологии.

удачи

Есть вещи, о которых автор документации 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, и очередь также гарантированно будет последовательной.