Question

I have recently become thread curious on iOS. Please point me in the direction you would take, to achieve (if possible) the following on modern iOS devices… thank you!

The user is typing in text, say a word every few seconds.

From time to time I want to launch DifficultProcess to do some semantic processing. In short, I guess I need to be able to do four things:

• launch DifficultProcess from main
• if DifficultProcess completes, get a message back from it to the same main
• abandon, get rid of, DifficultProcess if I want to, from main
• and finally the priority question: DifficultProcess must have much lower priority than main or user input, I want DifficultProcess to have really really looow priority; is that even possible?

What, essentially, are the calls one uses for A, B, C in modern (2011) (late January) iOS? I don’t care about Dad’s methods! And is “D” even possible in any way?

I guess those are the four ideas!

So in particular I want to send a message to, in other words call a routine in, the running background process (in that way, one could kill off the running background process if desired, or perhaps change it’s mode of operation etc).

(For anyone born before 1997, you will recognise that as a typical “speculative processing” paradigm.)

Thanks for pointers for anyone who can be bothered on this!

Answer 1

I would recommend using NSOperation and NSOperationQueue to manage background activity that you need to be able to cancel arbitrarily.

NSOperation’s -cancel and NSOperationQueue’s -cancelAllOperations are the methods to look at.

To get messages back from the background to the main thread, the dispatch_async-to-main-thread-queue technique is fine. You can combine this with a delegate protocol for your NSOperation to codify the messages you want to send back.

E.g.

@protocol MyOperationDelegate
- (void) operationStarted:(MyOperation *)operation;
- (void) makingProgressOnItem:(id)anItem otherInterestingItem:(NSDictionary *)otherItem remainingCount:(NSUInteger)count;
- (void) operationWillFinish:(MyOperation *)operation;
@end

@interface MyOperation
id <MyOperationDelegate> delegate;
@end

@implementation MyOperation
...

- (void) cancel
{ 
    [super cancel];

    // Tell the delegate we're about to finish (due to cancellation).
    dispatch_sync (dispatch_get_main_queue(), ^{
      [self.delegate operationWillFinish:self];
    });
}

- (void) main 
{
    // Check for cancellation

    if (self.isCancelled) return;

    // Starting

    dispatch_sync (dispatch_get_main_queue(), ^{
        [self.delegate operationStarted:self];
    });

    if (self.isCancelled) return; // Another cancel check


    // Send async progress messages periodically while doing some work

    while (workNotDone) 
    {
        // Do some work ...

        dispatch_async (dispatch_get_main_queue(), ^{
           [self.delegate makingProgressOnItem:foo otherInterestingItem:bar remainingCount:baz];
        });

       if (self.isCancelled) return;
    }


    // About to finish

    if (!self.isCancelled) {
        dispatch_sync (dispatch_get_main_queue(), ^{
           [self.delegate operationWillFinish:self];
        });
    }
}
@end

---

KVO is no good for interthread communication; the observation is received on the thread that originates the key value change. So, if your background thread changes a value, your background thread is going to receive the KVO about it. Probably not what you want.

Grandpa’s -performSelectorOnMainThread:withObject:waitUntilDone: continues to be a fine way to get messages back to the main thread. The limitation is that your messages can only access one object-based argument. The dispatch_async to the main thread doesn’t have this limitation.

If you want to fire off an asynchronous (or synchronous) NSNotification’s from a background thread to the main thread, you need to use -performSelectorOnMainThread.

NSNotification *note = [NSNotification notificationWithName:FinishedABunchOfWorkNotification object:self userInfo:nil];
[[NSNotificationCenter defaultCenter] performSelectorOnMainThread:@selector(postNotification:) withObject:note waitUntilDone:YES];